@j0hanz/filesystem-mcp 1.11.0 → 1.12.0

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

@@ -1,12 +1,13 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { Buffer } from 'node:buffer';
 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, withAbort } from '../lib/fs-helpers.js';
+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';
@@ -57,42 +58,68 @@ function createRegexMatcher(pattern, caseSensitive) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
     }
 }
-function createRegexReplacementMatcher(regex) {
-    const count = (content) => {
-        regex.lastIndex = 0;
+class RegexReplacementMatcher {
+    regex;
+    constructor(regex) {
+        this.regex = regex;
+    }
+    count(content) {
+        this.regex.lastIndex = 0;
         let matchCount = 0;
-        while (regex.exec(content) !== null) {
+        while (this.regex.exec(content) !== null) {
             matchCount++;
-            if (regex.lastIndex === 0) {
-                regex.lastIndex++;
+            if (this.regex.lastIndex === 0) {
+                this.regex.lastIndex++;
             }
         }
         return matchCount;
-    };
-    const replace = (content, replacement) => {
-        regex.lastIndex = 0;
-        return content.replace(regex, replacement);
-    };
-    return { count, replace };
+    }
+    replace(content, replacement) {
+        this.regex.lastIndex = 0;
+        return content.replace(this.regex, replacement);
+    }
 }
-function createLiteralReplacementMatcher(searchPattern, caseSensitive) {
-    if (!caseSensitive) {
-        const escaped = searchPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const regex = new RE2(escaped, 'gi');
-        return createRegexReplacementMatcher(regex);
+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;
     }
-    const count = (content) => {
+    testBuffer(buffer) {
+        if (!this.searchBuffer)
+            return true;
+        return buffer.indexOf(this.searchBuffer) !== -1;
+    }
+    count(content) {
         let matchCount = 0;
-        let pos = content.indexOf(searchPattern);
-        const patternLength = searchPattern.length;
+        let pos = content.indexOf(this.searchPattern);
         while (pos !== -1) {
             matchCount++;
-            pos = content.indexOf(searchPattern, pos + patternLength);
+            pos = content.indexOf(this.searchPattern, pos + this.patternLength);
         }
         return matchCount;
+    }
+    replace(content, replacement) {
+        return content.replaceAll(this.searchPattern, () => replacement);
+    }
+}
+function buildReplacementPlan(content, replacement, matcher) {
+    const matchCount = matcher.count(content);
+    if (matchCount === 0) {
+        return undefined;
+    }
+    return {
+        matchCount,
+        originalContent: content,
+        updatedContent: matcher.replace(content, replacement),
     };
-    const replace = (content, replacement) => content.replaceAll(searchPattern, () => replacement);
-    return { count, replace };
 }
 function formatFileTooLargeError(filePath, size, maxFileSize) {
     return `File too large: ${filePath} (${size} bytes > ${maxFileSize} bytes)`;
@@ -112,37 +139,29 @@ async function processEntry(entryPath, context) {
         return;
     }
     try {
-        const stats = await withAbort(fs.stat(validPath), signal);
-        if (stats.size > maxFileSize) {
-            summary.failedFiles++;
-            recordFailure(summary.failures, {
-                path: validPath,
-                error: formatFileTooLargeError(validPath, stats.size, maxFileSize),
-            });
+        const plan = await readReplacementPlan(validPath, {
+            matcher,
+            replacement,
+            maxFileSize,
+            signal,
+        });
+        if (!plan) {
             return;
         }
-        const content = await fs.readFile(validPath, {
-            encoding: 'utf-8',
-            signal,
+        summary.totalMatches += plan.matchCount;
+        summary.filesChanged++;
+        recordChangedFile(summary, validPath, plan.matchCount);
+        await maybeAppendPatchDiff(summary, {
+            filePath: validPath,
+            originalContent: plan.originalContent,
+            updatedContent: plan.updatedContent,
+            includeDiff: options.dryRun || options.returnDiff,
         });
-        const matchCount = matcher.count(content);
-        if (matchCount > 0) {
-            summary.totalMatches += matchCount;
-            summary.filesChanged++;
-            recordChangedFile(summary, validPath, matchCount);
-            const newContent = matcher.replace(content, replacement);
-            maybeAppendPatchDiff(summary, {
-                filePath: validPath,
-                originalContent: content,
-                updatedContent: newContent,
-                includeDiff: options.dryRun || options.returnDiff,
+        if (!options.dryRun) {
+            await atomicWriteFile(validPath, plan.updatedContent, {
+                encoding: 'utf-8',
+                signal,
             });
-            if (!options.dryRun) {
-                await atomicWriteFile(validPath, newContent, {
-                    encoding: 'utf-8',
-                    signal,
-                });
-            }
         }
     }
     catch (error) {
@@ -153,14 +172,51 @@ async function processEntry(entryPath, context) {
         });
     }
 }
-function maybeAppendPatchDiff(summary, params) {
+async function readReplacementPlan(validPath, context) {
+    let fileHandle;
+    try {
+        const fd = await fs.open(validPath, 'r');
+        fileHandle = fd;
+        const stats = await fileHandle.stat();
+        if (stats.size > context.maxFileSize) {
+            throw new Error(formatFileTooLargeError(validPath, stats.size, context.maxFileSize));
+        }
+        let content;
+        if (context.matcher.testBuffer) {
+            const buffer = await fileHandle.readFile({ signal: context.signal });
+            if (!context.matcher.testBuffer(buffer)) {
+                return undefined;
+            }
+            content = buffer.toString('utf-8');
+        }
+        else {
+            content = await fileHandle.readFile({
+                encoding: 'utf-8',
+                signal: context.signal,
+            });
+        }
+        return buildReplacementPlan(content, context.replacement, context.matcher);
+    }
+    finally {
+        if (fileHandle) {
+            await fileHandle.close();
+        }
+    }
+}
+async function maybeAppendPatchDiff(summary, params) {
     if (!params.includeDiff)
         return;
     if (summary.diff.length >= MAX_DIFF_SIZE) {
         summary.diffTruncated = true;
         return;
     }
-    const patch = createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified');
+    const patch = await new Promise((resolve) => {
+        createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
+            callback: (res) => {
+                resolve(res ?? '');
+            },
+        });
+    });
     if (summary.diff.length + patch.length <=
         MAX_DIFF_SIZE + DIFF_APPEND_BUFFER) {
         summary.diff += patch;
@@ -233,9 +289,14 @@ function createReplacementRegex(args) {
 function createReplacementMatcher(args) {
     const regex = createReplacementRegex(args);
     if (regex) {
-        return createRegexReplacementMatcher(regex);
+        return new RegexReplacementMatcher(regex);
+    }
+    if (!args.caseSensitive) {
+        const escaped = args.searchPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const caseInsensitiveRegex = new RE2(escaped, 'gi');
+        return new RegexReplacementMatcher(caseInsensitiveRegex);
     }
-    return createLiteralReplacementMatcher(args.searchPattern, args.caseSensitive);
+    return new LiteralReplacementMatcher(args.searchPattern, args.caseSensitive);
 }
 export async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
     const maxFileSize = MAX_TEXT_FILE_SIZE;
@@ -283,27 +344,7 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
         throttleModulo: 25,
         force: true,
     });
-    const failureSuffix = summary.failedFiles > 0 ? ` (${summary.failedFiles} failed)` : '';
-    return buildToolResponse(`Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${args.dryRun ? ' (Dry run)' : ''}`, {
-        ok: true,
-        matches: summary.totalMatches,
-        filesChanged: summary.filesChanged,
-        processedFiles: summary.processedFiles,
-        ...(summary.failedFiles > 0 ? { failedFiles: summary.failedFiles } : {}),
-        ...(summary.failures.length > 0 ? { failures: summary.failures } : {}),
-        ...(summary.changedFiles.length > 0
-            ? { changedFiles: summary.changedFiles }
-            : {}),
-        ...(summary.changedFilesTruncated ? { changedFilesTruncated: true } : {}),
-        ...((args.dryRun || args.returnDiff) && summary.diff
-            ? { diff: summary.diff }
-            : {}),
-        ...(summary.diffTruncated ? { diffTruncated: true } : {}),
-        ...(summary.stoppedReason
-            ? { stoppedReason: summary.stoppedReason }
-            : {}),
-        dryRun: args.dryRun,
-    });
+    return buildToolResponse(buildSearchAndReplaceText(summary, args.dryRun), buildSearchAndReplaceStructuredResult(summary, args));
 }
 export function registerSearchAndReplaceTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({
@@ -350,3 +391,28 @@ export function registerSearchAndReplaceTool(server, options = {}) {
         return;
     server.registerTool('search_and_replace', withDefaultIcons({ ...SEARCH_AND_REPLACE_TOOL }, options.iconInfo), validatedHandler);
 }
+function buildSearchAndReplaceText(summary, dryRun) {
+    const failureSuffix = summary.failedFiles > 0 ? ` (${summary.failedFiles} failed)` : '';
+    const dryRunSuffix = dryRun ? ' (Dry run)' : '';
+    return `Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${dryRunSuffix}`;
+}
+function buildSearchAndReplaceStructuredResult(summary, args) {
+    return {
+        ok: true,
+        matches: summary.totalMatches,
+        filesChanged: summary.filesChanged,
+        processedFiles: summary.processedFiles,
+        ...(summary.failedFiles > 0 ? { failedFiles: summary.failedFiles } : {}),
+        ...(summary.failures.length > 0 ? { failures: summary.failures } : {}),
+        ...(summary.changedFiles.length > 0
+            ? { changedFiles: summary.changedFiles }
+            : {}),
+        ...(summary.changedFilesTruncated ? { changedFilesTruncated: true } : {}),
+        ...((args.dryRun || args.returnDiff) && summary.diff
+            ? { diff: summary.diff }
+            : {}),
+        ...(summary.diffTruncated ? { diffTruncated: true } : {}),
+        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
+        dryRun: args.dryRun,
+    };
+}

package/dist/tools/roots.js

@@ -12,7 +12,7 @@ export const LIST_ALLOWED_DIRECTORIES_TOOL = {
     outputSchema: ListAllowedDirectoriesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
     nuances: ['Returns absolute paths of all allowed directories.'],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 function buildTextRoots(dirs) {
     if (dirs.length === 0) {