@j0hanz/filesystem-mcp 1.11.1 → 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,57 @@ 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;
+    }
+    testBuffer(buffer) {
+        if (!this.searchBuffer)
+            return true;
+        return buffer.indexOf(this.searchBuffer) !== -1;
     }
-    const count = (content) => {
+    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;
-    };
-    const replace = (content, replacement) => content.replaceAll(searchPattern, () => replacement);
-    return { count, replace };
+    }
+    replace(content, replacement) {
+        return content.replaceAll(this.searchPattern, () => replacement);
+    }
 }
 function buildReplacementPlan(content, replacement, matcher) {
     const matchCount = matcher.count(content);
@@ -135,7 +151,7 @@ async function processEntry(entryPath, context) {
         summary.totalMatches += plan.matchCount;
         summary.filesChanged++;
         recordChangedFile(summary, validPath, plan.matchCount);
-        maybeAppendPatchDiff(summary, {
+        await maybeAppendPatchDiff(summary, {
             filePath: validPath,
             originalContent: plan.originalContent,
             updatedContent: plan.updatedContent,
@@ -157,24 +173,50 @@ async function processEntry(entryPath, context) {
     }
 }
 async function readReplacementPlan(validPath, context) {
-    const stats = await withAbort(fs.stat(validPath), context.signal);
-    if (stats.size > context.maxFileSize) {
-        throw new Error(formatFileTooLargeError(validPath, stats.size, context.maxFileSize));
+    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();
+        }
     }
-    const content = await fs.readFile(validPath, {
-        encoding: 'utf-8',
-        signal: context.signal,
-    });
-    return buildReplacementPlan(content, context.replacement, context.matcher);
 }
-function maybeAppendPatchDiff(summary, params) {
+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;
@@ -247,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;