@j0hanz/filesystem-mcp 1.13.2 → 1.14.0

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

@@ -1,8 +1,6 @@
 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 { createTwoFilesPatch } from 'diff';
 import RE2 from 're2';
 import safeRegex from 'safe-regex2';
@@ -13,7 +11,7 @@ import { atomicWriteFile } from '../lib/fs-helpers.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 +24,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);
@@ -60,64 +52,49 @@ function createRegexMatcher(pattern, caseSensitive) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
     }
 }
-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 {
+        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 +110,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 +120,12 @@ async function processEntry(entryPath) {
         summary.failedFiles++;
         recordFailure(summary.failures, {
             path: entryPath,
-            error: formatUnknownErrorMessage(error),
+            error: buildStructuredError(error, ErrorCode.E_UNKNOWN, entryPath),
         });
         return;
     }
     try {
-        const plan = await readReplacementPlan(validPath);
+        const plan = await readReplacementPlan(validPath, ctx);
         if (!plan) {
             return;
         }
@@ -172,12 +149,12 @@ async function processEntry(entryPath) {
         summary.failedFiles++;
         recordFailure(summary.failures, {
             path: validPath,
-            error: formatUnknownErrorMessage(error),
+            error: buildStructuredError(error, ErrorCode.E_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');
@@ -234,7 +211,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 +226,6 @@ async function processEntriesConcurrently(entries, options) {
             stoppedByLimit = true;
             break;
         }
-        if (seen.has(entry.path))
-            continue;
-        seen.add(entry.path);
         await waitForSlot();
         onEntry();
         dispatched++;
@@ -297,14 +270,14 @@ function createReplacementRegex(args) {
 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;
@@ -323,10 +296,7 @@ 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,
@@ -338,7 +308,7 @@ 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 } : {}),
@@ -348,15 +318,9 @@ async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
                 throttleModulo: 25,
             });
         },
-        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';
     }
@@ -370,6 +334,7 @@ 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) => {
@@ -437,6 +402,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,6 +34,7 @@ export function registerListAllowedDirectoriesTool(server, options = {}) {
     const handler = (_args, extra) => executeToolWithDiagnostics({
         toolName: 'roots',
         extra,
+        outputSchema: ListAllowedDirectoriesOutputSchema,
         run: () => handleListAllowedDirectories(),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN),
     });
@@ -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'}`;
         },
     });