@j0hanz/filesystem-mcp 1.13.2 → 1.14.1

package/dist/lib/file-operations/core.js

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
 import ignore, {} from 'ignore';
 import { isNodeError } from '../errors.js';
 import { toPosixPath } from '../paths.js';
@@ -40,7 +40,8 @@ export function compareOptionalNumberDesc(left, right, tieBreak) {
 }
 export function stableSortByDerivedString(items, derive, tieBreak) {
     const decorated = [];
-    for (let index = 0; index < items.length; index += 1) {
+    const len = items.length;
+    for (let index = 0; index < len; index++) {
         const item = items[index];
         if (item === undefined)
             continue;
@@ -59,7 +60,8 @@ export function stableSortByDerivedString(items, derive, tieBreak) {
             return tiedCompare;
         return left.index - right.index;
     });
-    for (let index = 0; index < decorated.length; index += 1) {
+    const decoratedLen = decorated.length;
+    for (let index = 0; index < decoratedLen; index++) {
         const entry = decorated[index];
         if (!entry)
             continue;
@@ -74,13 +76,14 @@ export function applyIndexedValues(output, results) {
     }
 }
 export function applyIndexedErrors(options) {
-    for (const failure of options.errors) {
-        const resolvedIndex = options.resolveIndex(failure.index);
+    const { output, errors, resolveIndex, buildValue } = options;
+    for (const failure of errors) {
+        const resolvedIndex = resolveIndex(failure.index);
         if (resolvedIndex === undefined)
             continue;
-        if (resolvedIndex < 0 || resolvedIndex >= options.output.length)
+        if (resolvedIndex < 0 || resolvedIndex >= output.length)
             continue;
-        options.output[resolvedIndex] = options.buildValue(resolvedIndex, failure.error);
+        output[resolvedIndex] = buildValue(resolvedIndex, failure.error);
     }
 }
 export async function isEntryAccessibleByType(entryPath, entryType, rootDirectories, signal, deps) {
@@ -101,8 +104,9 @@ export async function isEntryAccessibleByType(entryPath, entryType, rootDirector
 }
 function parseGitignoreLines(contents) {
     const lines = [];
-    for (const line of contents.split(/\r?\n/u)) {
-        const trimmed = line.trim();
+    const parts = contents.split(/\r?\n/u);
+    for (const part of parts) {
+        const trimmed = part.trim();
         if (trimmed.length > 0) {
             lines.push(trimmed);
         }
@@ -110,13 +114,15 @@ function parseGitignoreLines(contents) {
     return lines;
 }
 export async function loadRootGitignore(root, signal) {
-    const gitignorePath = path.join(root, '.gitignore');
-    let contents;
+    const gitignorePath = join(root, '.gitignore');
     try {
-        contents = await fs.readFile(gitignorePath, {
+        const contents = await readFile(gitignorePath, {
             encoding: 'utf-8',
             signal,
         });
+        const matcher = ignore();
+        matcher.add(parseGitignoreLines(contents));
+        return matcher;
     }
     catch (error) {
         if (isNodeError(error) && error.code === 'ENOENT') {
@@ -124,16 +130,13 @@ export async function loadRootGitignore(root, signal) {
         }
         throw error;
     }
-    const matcher = ignore();
-    matcher.add(parseGitignoreLines(contents));
-    return matcher;
 }
 export function isIgnoredByGitignore(matcher, root, absolutePath, options = {}) {
-    let relative = options.relativePath;
-    relative ??= path.relative(root, absolutePath);
-    if (relative.length === 0)
+    let { relativePath } = options;
+    relativePath ??= relative(root, absolutePath);
+    if (relativePath.length === 0)
         return false;
-    const normalized = toPosixPath(relative);
+    const normalized = toPosixPath(relativePath);
     if (options.isDirectory) {
         return matcher.ignores(normalized.endsWith('/') ? normalized : `${normalized}/`);
     }

package/dist/lib/file-operations/metadata.d.ts

@@ -1,5 +1,5 @@
 import type { FileInfo, GetMultipleFileInfoResult, ListDirectoryResult } from '../../config.js';
-import type { EntryType } from './core.js';
+import { type EntryType } from './core.js';
 interface FileInfoOptions {
     includeMimeType?: boolean | undefined;
     signal?: AbortSignal | undefined;
@@ -60,7 +60,7 @@ interface ReadMultipleResult {
     endLine?: number;
     linesRead?: number;
     hasMoreLines?: boolean;
-    error?: string;
+    error?: Error;
 }
 interface ReadMultipleOptions {
     encoding?: BufferEncoding;

package/dist/lib/file-operations/metadata.js

@@ -1,11 +1,53 @@
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
+import { lstat, readdir, readlink, stat, } from 'node:fs';
+import { basename, join, parse, relative } from 'node:path';
+import { assertNotAborted, withAbort, withTimedAbortSignal } from '../abort.js';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_LIST_MAX_ENTRIES, DEFAULT_MAX_DEPTH, DEFAULT_READ_MANY_MAX_TOTAL_SIZE, DEFAULT_SEARCH_TIMEOUT_MS, getMimeType, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../constants.js';
 import { isAbortError } from '../errors.js';
-import { assertNotAborted, getFileType, isHidden, processInParallel, readFile, readFileWithStats, withAbort, withTimedAbortSignal, } from '../fs-helpers.js';
+import { getFileType, isHidden, processInParallel, readFile, readFileWithStats, } from '../fs-helpers.js';
+import { assertSafeGlobPattern } from '../globs.js';
 import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, normalizePath, toPosixPath, validateExistingDirectory, validateExistingPath, validateExistingPathDetailed, } from '../paths.js';
 import { applyIndexedErrors, applyIndexedValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, withOptionalStoppedReason, } from './core.js';
 import { globEntries } from './traversal.js';
+function statAsync(filePath) {
+    return new Promise((resolve, reject) => {
+        stat(filePath, (err, stats) => {
+            if (err)
+                reject(err);
+            else
+                resolve(stats);
+        });
+    });
+}
+function readlinkAsync(filePath) {
+    return new Promise((resolve, reject) => {
+        readlink(filePath, (err, linkString) => {
+            if (err)
+                reject(err);
+            else
+                resolve(linkString);
+        });
+    });
+}
+function readdirAsync(dirPath, options) {
+    return new Promise((resolve, reject) => {
+        readdir(dirPath, options, (err, files) => {
+            if (err)
+                reject(err);
+            else
+                resolve(files);
+        });
+    });
+}
+function lstatAsync(filePath) {
+    return new Promise((resolve, reject) => {
+        lstat(filePath, (err, stats) => {
+            if (err)
+                reject(err);
+            else
+                resolve(stats);
+        });
+    });
+}
 const ACCESS_DEPS = {
     normalizePath,
     isPathWithinDirectories,
@@ -48,7 +90,7 @@ function buildFileInfoResult(name, requestedPath, isSymlink, stats, mimeType, sy
 async function getSymlinkTarget(pathToRead, signal) {
     assertNotAborted(signal);
     try {
-        return await withAbort(fsp.readlink(pathToRead), signal);
+        return await withAbort(readlinkAsync(pathToRead), signal);
     }
     catch (error) {
         if (isAbortError(error))
@@ -61,14 +103,14 @@ export async function getFileInfo(filePath, options = {}) {
     assertNotAborted(signal);
     const { requestedPath, resolvedPath, isSymlink } = await validateExistingPathDetailed(filePath, signal);
     assertAllowedFileAccess(requestedPath, resolvedPath);
-    const { base: name, ext: rawExt } = path.parse(requestedPath);
+    const { base: name, ext: rawExt } = parse(requestedPath);
     const ext = rawExt.toLowerCase();
     const includeMimeType = options.includeMimeType !== false;
     const mimeType = includeMimeType && ext.length > 0 ? getMimeType(ext) : undefined;
     const symlinkTarget = isSymlink
         ? await getSymlinkTarget(requestedPath, signal)
         : undefined;
-    const stats = await withAbort(fsp.stat(resolvedPath), signal);
+    const stats = await withAbort(statAsync(resolvedPath), signal);
     return buildFileInfoResult(name, requestedPath, isSymlink, stats, mimeType, symlinkTarget);
 }
 function buildEmptyResult() {
@@ -130,7 +172,7 @@ export async function getMultipleFileInfo(paths, options = {}) {
             : undefined,
         buildValue: (resolvedIndex, error) => ({
             path: paths[resolvedIndex] ?? UNKNOWN_PATH,
-            error: error.message,
+            error,
         }),
     });
     return {
@@ -149,6 +191,7 @@ function normalizeListOptions(options) {
         timeoutMs: options.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
     };
     if (options.pattern && options.pattern.length > 0) {
+        assertSafeGlobPattern(options.pattern);
         normalized.pattern = options.pattern;
     }
     return normalized;
@@ -166,12 +209,12 @@ function resolveMaxDepth(normalized) {
     return normalized.pattern ? normalized.maxDepth : 1;
 }
 async function* readDirectoryEntries(basePath, normalized, needsStats, signal) {
-    const dirents = await withAbort(fsp.readdir(basePath, { withFileTypes: true }), signal);
+    const dirents = await withAbort(readdirAsync(basePath, { withFileTypes: true }), signal);
     if (!needsStats) {
         for (const dirent of dirents) {
             if (!normalized.includeHidden && isHidden(dirent.name))
                 continue;
-            yield { path: path.join(basePath, dirent.name), dirent };
+            yield { path: join(basePath, dirent.name), dirent };
         }
         return;
     }
@@ -179,12 +222,12 @@ async function* readDirectoryEntries(basePath, normalized, needsStats, signal) {
     for (const dirent of dirents) {
         if (!normalized.includeHidden && isHidden(dirent.name))
             continue;
-        filtered.push({ dirent, entryPath: path.join(basePath, dirent.name) });
+        filtered.push({ dirent, entryPath: join(basePath, dirent.name) });
     }
     const { results, errors } = await processInParallel(filtered, async ({ entryPath, dirent }) => ({
         path: entryPath,
         dirent,
-        stats: await withAbort(fsp.lstat(entryPath), signal),
+        stats: await withAbort(lstatAsync(entryPath), signal),
     }), PARALLEL_CONCURRENCY, signal);
     if (errors.length > 0) {
         throw errors[0]?.error ?? new Error('Failed to read entry stats');
@@ -214,13 +257,13 @@ function shouldUseFastPath(normalized, maxDepth) {
         maxDepth === 1);
 }
 function resolveRelativePath(basePath, entryPath) {
-    return path.relative(basePath, entryPath) || path.basename(entryPath);
+    return relative(basePath, entryPath) || basename(entryPath);
 }
 async function resolveSymlinkTarget(entryType, includeSymlinkTargets, entryPath) {
     if (entryType !== 'symlink' || !includeSymlinkTargets) {
         return undefined;
     }
-    return fsp.readlink(entryPath).catch(() => undefined);
+    return readlinkAsync(entryPath).catch(() => undefined);
 }
 function updateTotals(entryType, totals) {
     if (entryType === 'file')
@@ -232,7 +275,7 @@ function buildDirectoryEntry(basePath, entry, entryType, needsStats, symlinkTarg
     const size = needsStats && entry.stats?.isFile() ? entry.stats.size : undefined;
     const modified = needsStats ? entry.stats?.mtime : undefined;
     return {
-        name: path.basename(entry.path),
+        name: basename(entry.path),
         path: entry.path,
         relativePath: resolveRelativePath(basePath, entry.path),
         type: entryType,
@@ -421,7 +464,7 @@ async function resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher,
         return null;
     }
     const relativePosix = toPosixPath(resolveRelativePath(root, entry.path));
-    const name = path.basename(entry.path);
+    const name = basename(entry.path);
     return { type, relativePosix, name };
 }
 function upsertChildNode(parent, nodeByPath, resolved, childPathIndexByParent) {
@@ -521,7 +564,7 @@ export async function treeDirectory(dirPath, options = {}) {
             ? null
             : await loadRootGitignore(root, signal);
         const rootNode = {
-            name: path.basename(root) || root,
+            name: basename(root) || root,
             type: 'directory',
             relativePath: '.',
             children: [],
@@ -590,6 +633,7 @@ function buildReadOptions(options) {
     const readOptions = {
         encoding: options.encoding,
         maxSize: options.maxSize,
+        skipBinary: true,
     };
     applyLineSelection(readOptions, options);
     return readOptions;
@@ -653,10 +697,13 @@ function applyLineSelection(target, source) {
         target.head = source.head;
     if (source.tail !== undefined)
         target.tail = source.tail;
-    if (source.startLine !== undefined)
-        target.startLine = source.startLine;
-    if (source.endLine !== undefined)
+    if (source.endLine !== undefined) {
+        target.startLine = source.startLine ?? 1;
         target.endLine = source.endLine;
+    }
+    else if (source.startLine !== undefined) {
+        target.startLine = source.startLine;
+    }
 }
 function resolveNormalizedReadOptions(options) {
     const { signal, ...rest } = options;
@@ -669,7 +716,7 @@ function resolveNormalizedReadOptions(options) {
 }
 async function validateFile(filePath, index, signal) {
     const validPath = await validateExistingPath(filePath, signal);
-    const stats = await withAbort(fsp.stat(validPath), signal);
+    const stats = await withAbort(statAsync(validPath), signal);
     return { filePath, index, validPath, stats };
 }
 function markRemainingSkipped(startIndex, total, skippedBudget) {
@@ -804,7 +851,7 @@ function applySkippedBudget(output, skippedBudget, filePaths, maxTotalSize) {
             continue;
         output[index] = {
             path: filePath,
-            error: `Skipped: combined estimated read would exceed maxTotalSize (${maxTotalSize} bytes)`,
+            error: new Error(`Skipped: combined estimated read would exceed maxTotalSize (${maxTotalSize} bytes)`),
         };
     }
 }
@@ -823,7 +870,7 @@ export async function readMultipleFiles(filePaths, options = {}) {
         resolveIndex: (failureIndex) => resolveErrorOriginalIndex(failureIndex, filesToProcess, filePaths.length),
         buildValue: (resolvedIndex, error) => ({
             path: filePaths[resolvedIndex] ?? UNKNOWN_PATH,
-            error: error.message,
+            error,
         }),
     });
     applySkippedBudget(output, skippedBudget, filePaths, normalized.maxTotalSize);

package/dist/lib/file-operations/search.d.ts

@@ -12,7 +12,6 @@ declare const SearchOptionsSchema: z.ZodObject<{
     contextLines: z.ZodInt;
     wholeWord: z.ZodBoolean;
     isLiteral: z.ZodBoolean;
-    multiline: z.ZodBoolean;
     includeHidden: z.ZodBoolean;
     baseNameMatch: z.ZodBoolean;
     caseSensitiveFileMatch: z.ZodBoolean;