@j0hanz/filesystem-mcp 1.13.2 → 1.14.1

package/dist/tools/replace-in-files.js

@@ -1,19 +1,16 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { Buffer } from 'node:buffer';
-import { performance } from 'node:perf_hooks';
+import { open } from 'node:fs/promises';
+import { basename, relative } from 'node:path';
 import { createTwoFilesPatch } from 'diff';
 import RE2 from 're2';
-import safeRegex from 'safe-regex2';
 import { DEFAULT_EXCLUDE_PATTERNS, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
 import { globEntries } from '../lib/file-operations/traversal.js';
 import { atomicWriteFile } from '../lib/fs-helpers.js';
+import { Logger } from '../lib/logger.js';
 import { validateExistingPath, validatePathForWrite } from '../lib/paths.js';
-import { reportPeriodicProgress } from '../lib/utils.js';
 import { SearchAndReplaceInputSchema, SearchAndReplaceOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createToolProgressSession, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildStructuredError, buildToolErrorResponse, buildToolResponse, createToolProgressSession, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 export const SEARCH_AND_REPLACE_TOOL = {
     name: 'search_and_replace',
@@ -26,12 +23,6 @@ export const SEARCH_AND_REPLACE_TOOL = {
     outputSchema: SearchAndReplaceOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
     taskSupport: 'optional',
-    gotchas: [
-        'Replaces ALL occurrences — not just the first. Use `edit` for single replacements.',
-    ],
-    nuances: [
-        'Changed-file sample and failure sample are capped/truncated in output.',
-    ],
 };
 const MAX_FAILURES = 20;
 const REPLACE_CONCURRENCY = Math.min(PARALLEL_CONCURRENCY, 8);
@@ -44,7 +35,7 @@ function recordFailure(failures, failure) {
     failures.push(failure);
 }
 function recordChangedFile(summary, filePath, matchCount) {
-    const relativePath = path.relative(summary.root, filePath);
+    const relativePath = relative(summary.root, filePath);
     if (summary.changedFiles.length < MAX_CHANGED_FILES) {
         summary.changedFiles.push({ path: relativePath, matches: matchCount });
         return;
@@ -57,67 +48,55 @@ function createRegexMatcher(pattern, caseSensitive) {
         return new RE2(pattern, flags);
     }
     catch (error) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
+        throw new McpError(ErrorCode.INVALID_PATTERN, `Invalid regex pattern: ${formatUnknownErrorMessage(error)} (RE2: no lookahead/lookbehind/backrefs)`);
     }
 }
-class RegexReplacementMatcher {
-    regex;
-    constructor(regex) {
-        this.regex = regex;
-    }
-    count(content) {
-        this.regex.lastIndex = 0;
-        let matchCount = 0;
-        while (this.regex.exec(content) !== null) {
-            matchCount++;
-            if (this.regex.lastIndex === 0) {
-                this.regex.lastIndex++;
+function createRegexReplacementMatcher(regex) {
+    return {
+        testBuffer(buffer) {
+            return regex.test(buffer);
+        },
+        count(content) {
+            regex.lastIndex = 0;
+            let matchCount = 0;
+            while (regex.exec(content) !== null) {
+                matchCount++;
+                if (regex.lastIndex === 0) {
+                    regex.lastIndex++;
+                }
             }
-        }
-        return matchCount;
-    }
-    replace(content, replacement) {
-        this.regex.lastIndex = 0;
-        return content.replace(this.regex, replacement);
-    }
-}
-class LiteralReplacementMatcher {
-    searchPattern;
-    caseSensitive;
-    patternLength;
-    searchBuffer;
-    constructor(searchPattern, caseSensitive) {
-        this.searchPattern = searchPattern;
-        this.caseSensitive = caseSensitive;
-        this.patternLength = searchPattern.length;
-        this.searchBuffer = caseSensitive
-            ? Buffer.from(searchPattern, 'utf8')
-            : null;
-    }
-    testBuffer(buffer) {
-        if (!this.searchBuffer)
-            return true;
-        return buffer.indexOf(this.searchBuffer) !== -1;
-    }
-    count(content) {
-        let matchCount = 0;
-        let pos = content.indexOf(this.searchPattern);
-        while (pos !== -1) {
-            matchCount++;
-            pos = content.indexOf(this.searchPattern, pos + this.patternLength);
-        }
-        return matchCount;
-    }
-    replace(content, replacement) {
-        return content.replaceAll(this.searchPattern, () => replacement);
-    }
+            return matchCount;
+        },
+        replace(content, replacement) {
+            regex.lastIndex = 0;
+            return content.replace(regex, replacement);
+        },
+    };
 }
-const replaceContextStorage = new AsyncLocalStorage();
-function getReplaceContext() {
-    const ctx = replaceContextStorage.getStore();
-    if (!ctx)
-        throw new Error('Replace context not found in AsyncLocalStorage');
-    return ctx;
+function createLiteralReplacementMatcher(searchPattern, caseSensitive) {
+    const patternLength = searchPattern.length;
+    const searchBuffer = caseSensitive
+        ? Buffer.from(searchPattern, 'utf8')
+        : null;
+    return {
+        testBuffer(buffer) {
+            if (!searchBuffer)
+                return true;
+            return buffer.indexOf(searchBuffer) !== -1;
+        },
+        count(content) {
+            let matchCount = 0;
+            let pos = content.indexOf(searchPattern);
+            while (pos !== -1) {
+                matchCount++;
+                pos = content.indexOf(searchPattern, pos + patternLength);
+            }
+            return matchCount;
+        },
+        replace(content, replacement) {
+            return content.replaceAll(searchPattern, () => replacement);
+        },
+    };
 }
 function buildReplacementPlan(content, replacement, matcher) {
     const matchCount = matcher.count(content);
@@ -133,8 +112,8 @@ function buildReplacementPlan(content, replacement, matcher) {
 function formatFileTooLargeError(filePath, size, maxFileSize) {
     return `File too large: ${filePath} (${size} bytes > ${maxFileSize} bytes)`;
 }
-async function processEntry(entryPath) {
-    const { options, signal, summary } = getReplaceContext();
+async function processEntry(entryPath, ctx) {
+    const { options, signal, summary } = ctx;
     let validPath;
     try {
         validPath = await validatePathForWrite(entryPath, signal);
@@ -143,12 +122,12 @@ async function processEntry(entryPath) {
         summary.failedFiles++;
         recordFailure(summary.failures, {
             path: entryPath,
-            error: formatUnknownErrorMessage(error),
+            error: buildStructuredError(error, ErrorCode.UNKNOWN, entryPath),
         });
         return;
     }
     try {
-        const plan = await readReplacementPlan(validPath);
+        const plan = await readReplacementPlan(validPath, ctx);
         if (!plan) {
             return;
         }
@@ -172,15 +151,15 @@ async function processEntry(entryPath) {
         summary.failedFiles++;
         recordFailure(summary.failures, {
             path: validPath,
-            error: formatUnknownErrorMessage(error),
+            error: buildStructuredError(error, ErrorCode.UNKNOWN, validPath),
         });
     }
 }
-async function readReplacementPlan(validPath) {
-    const { matcher, replacement, maxFileSize, signal } = getReplaceContext();
+async function readReplacementPlan(validPath, ctx) {
+    const { matcher, replacement, maxFileSize, signal } = ctx;
     let fileHandle;
     try {
-        const fd = await fs.open(validPath, 'r');
+        const fd = await open(validPath, 'r');
         fileHandle = fd;
         const stats = await fileHandle.stat();
         if (stats.size > maxFileSize) {
@@ -218,7 +197,7 @@ async function maybeAppendPatchDiff(summary, params) {
     const patch = await new Promise((resolve) => {
         // Defer to event loop to avoid blocking on large diffs
         setImmediate(() => {
-            createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
+            createTwoFilesPatch(basename(params.filePath), basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
                 callback: (res) => {
                     resolve(res ?? '');
                 },
@@ -234,7 +213,6 @@ async function maybeAppendPatchDiff(summary, params) {
 }
 async function processEntriesConcurrently(entries, options) {
     const pending = new Set();
-    const seen = new Set();
     const { signal, concurrency, maxEntries, onEntry, runEntry } = options;
     let dispatched = 0;
     let stoppedByLimit = false;
@@ -250,9 +228,6 @@ async function processEntriesConcurrently(entries, options) {
             stoppedByLimit = true;
             break;
         }
-        if (seen.has(entry.path))
-            continue;
-        seen.add(entry.path);
         await waitForSlot();
         onEntry();
         dispatched++;
@@ -289,22 +264,19 @@ async function resolveSearchRoot(pathValue, signal) {
 function createReplacementRegex(args) {
     if (!args.isRegex)
         return undefined;
-    if (!safeRegex(args.searchPattern)) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, `Unsafe regex pattern: ${args.searchPattern}`);
-    }
     return createRegexMatcher(args.searchPattern, args.caseSensitive);
 }
 function createReplacementMatcher(args) {
     const regex = createReplacementRegex(args);
     if (regex) {
-        return new RegexReplacementMatcher(regex);
+        return createRegexReplacementMatcher(regex);
     }
     if (!args.caseSensitive) {
         const escaped = args.searchPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const caseInsensitiveRegex = new RE2(escaped, 'gi');
-        return new RegexReplacementMatcher(caseInsensitiveRegex);
+        return createRegexReplacementMatcher(caseInsensitiveRegex);
     }
-    return new LiteralReplacementMatcher(args.searchPattern, args.caseSensitive);
+    return createLiteralReplacementMatcher(args.searchPattern, args.caseSensitive);
 }
 async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
     const maxFileSize = MAX_TEXT_FILE_SIZE;
@@ -314,7 +286,7 @@ async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
         cwd: root,
         pattern: args.filePattern,
         excludePatterns: args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS,
-        includeHidden: args.includeHidden ?? false,
+        includeHidden: args.includeHidden,
         baseNameMatch: false,
         caseSensitiveMatch: true, // Default to sensitive for file paths
         followSymbolicLinks: false,
@@ -323,14 +295,11 @@ async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
         suppressErrors: true,
     });
     const summary = createReplaceSummary(root);
-    const timerStartName = `searchAndReplaceStart_${Date.now()}`;
-    const timerEndName = `searchAndReplaceEnd_${Date.now()}`;
-    const metricName = `searchAndReplace_${Date.now()}`;
-    performance.mark(timerStartName);
+    const t0 = performance.now();
     const context = {
         options: {
             dryRun: args.dryRun,
-            returnDiff: args.returnDiff ?? false,
+            returnDiff: args.returnDiff,
         },
         replacement: args.replacement,
         matcher,
@@ -338,38 +307,31 @@ async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
         signal,
         summary,
     };
-    const { stoppedByLimit } = await replaceContextStorage.run(context, () => processEntriesConcurrently(entries, {
+    const { stoppedByLimit } = await processEntriesConcurrently(entries, {
         signal,
         concurrency: REPLACE_CONCURRENCY,
         ...(args.maxFiles !== undefined ? { maxEntries: args.maxFiles } : {}),
         onEntry: () => {
             summary.processedFiles++;
-            reportPeriodicProgress(onProgress, summary.processedFiles, {
-                throttleModulo: 25,
-            });
+            onProgress({ current: summary.processedFiles });
         },
-        runEntry: processEntry,
-    }));
-    performance.mark(timerEndName);
-    performance.measure(metricName, timerStartName, timerEndName);
-    const durationMs = performance.getEntriesByName(metricName)[0]?.duration ?? 0;
-    performance.clearMarks(timerStartName);
-    performance.clearMarks(timerEndName);
-    performance.clearMeasures(metricName);
-    summary.perfTimeMs = durationMs;
+        runEntry: (entryPath) => processEntry(entryPath, context),
+    });
+    summary.perfTimeMs = performance.now() - t0;
     if (stoppedByLimit) {
         summary.stoppedReason = 'maxFiles';
     }
-    reportPeriodicProgress(onProgress, summary.processedFiles, {
-        throttleModulo: 25,
-        force: true,
-    });
+    onProgress({ current: summary.processedFiles });
+    if (!args.dryRun && summary.totalMatches > 0) {
+        Logger.info(`search_and_replace: ${summary.filesChanged} file(s), ${summary.totalMatches} match(es)`);
+    }
     return buildToolResponse(buildSearchAndReplaceText(summary, args.dryRun), buildSearchAndReplaceStructuredResult(summary, args));
 }
 export function registerSearchAndReplaceTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({
         toolName: 'search_and_replace',
         extra,
+        outputSchema: SearchAndReplaceOutputSchema,
         timedSignal: {},
         ...(args.path ? { context: { path: args.path } } : {}),
         run: async (signal) => {
@@ -401,7 +363,7 @@ export function registerSearchAndReplaceTool(server, options = {}) {
                 throw error;
             }
         },
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
     const { isInitialized } = options;
     const wrappedHandler = wrapToolHandler(handler, {
@@ -437,6 +399,5 @@ function buildSearchAndReplaceStructuredResult(summary, args) {
             : {}),
         ...(summary.diffTruncated ? { diffTruncated: true } : {}),
         ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
-        dryRun: args.dryRun,
     };
 }

package/dist/tools/roots.js

@@ -11,7 +11,6 @@ export const LIST_ALLOWED_DIRECTORIES_TOOL = {
     inputSchema: ListAllowedDirectoriesInputSchema,
     outputSchema: ListAllowedDirectoriesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    nuances: ['Returns absolute paths of all allowed directories.'],
     taskSupport: 'forbidden',
 };
 function buildTextRoots(dirs) {
@@ -28,8 +27,6 @@ function handleListAllowedDirectories() {
     const structured = {
         ok: true,
         directories: dirs,
-        rootsCount: dirs.length,
-        hasMultipleRoots: dirs.length > 1,
     };
     return buildToolResponse(buildTextRoots(dirs), structured);
 }
@@ -37,8 +34,9 @@ export function registerListAllowedDirectoriesTool(server, options = {}) {
     const handler = (_args, extra) => executeToolWithDiagnostics({
         toolName: 'roots',
         extra,
+        outputSchema: ListAllowedDirectoriesOutputSchema,
         run: () => handleListAllowedDirectories(),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN),
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
@@ -47,9 +45,7 @@ export function registerListAllowedDirectoriesTool(server, options = {}) {
             if (result.isError)
                 return `≣ roots • failed`;
             const sc = result.structuredContent;
-            if (!sc.ok)
-                return `≣ roots • failed`;
-            const count = sc.rootsCount ?? 0;
+            const count = sc.directories?.length ?? 0;
             return `≣ roots • ${count} ${count === 1 ? 'root' : 'roots'}`;
         },
     });