@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

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

@@ -1,31 +1,146 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { Buffer } from 'node:buffer';
-import { open } from 'node:fs/promises';
-import { basename, relative } from 'node:path';
+import { dirname, join } from 'node:path';
+import * as z from 'zod/v4';
 import { createTwoFilesPatch } from 'diff';
-import RE2 from 're2';
-import { DEFAULT_EXCLUDE_PATTERNS, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../lib/constants.js';
-import { classifyError, 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 { SearchAndReplaceInputSchema, SearchAndReplaceOutputSchema, } from '../schemas.js';
-import { FILE_EDIT_ICONS } from './icons.js';
-import { buildStructuredError, buildToolErrorResponse, buildToolResponse, createToolProgressSession, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const SEARCH_AND_REPLACE_TOOL = {
-    name: 'search_and_replace',
-    title: 'Search and Replace',
-    description: 'Bulk search-and-replace across files matching a glob. ' +
-        'Replaces ALL occurrences per file (unlike `edit`: first only). ' +
-        'Always `dryRun:true` first \u2014 returns a unified diff. ' +
-        'Literal matching by default; `isRegex:true` enables RE2 with capture groups ($1, $2).',
-    inputSchema: SearchAndReplaceInputSchema,
-    outputSchema: SearchAndReplaceOutputSchema,
-    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
-    icons: FILE_EDIT_ICONS,
-    taskSupport: 'optional',
-};
+import { processEntriesConcurrently, StoppedReasonSchema } from '../core/concurrency.js';
+import { ErrorCode, formatUnknownErrorMessage, FsError, Problem, rethrowIfAborted, } from '../core/errors.js';
+import { buildFileResourceLink } from '../core/file-uri.js';
+import { truncateProgressPattern } from '../core/fmt.js';
+import { DEFAULT_EXCLUDE_PATTERNS, globEntries } from '../core/glob.js';
+import { detectMimeFromContent } from '../core/mime.js';
+import { toPosixRelative } from '../core/path.js';
+import { escapeRegexLiteral } from '../core/primitives.js';
+import { readFileBufferWithLimit } from '../core/read.js';
+import { defaultFalseBoolean, includeHiddenField, includeIgnoredField, isBlank, maxDepthField, NonNegInt, OperationSummarySchema, OptionalPath, PerFileErrorSchema, SafeGlobPattern, } from '../core/schema.js';
+import { compileRegex, freeRegex } from '../core/search.js';
+import { DEFAULT_SEARCH_RESULTS, DEFAULT_SEARCH_TIMEOUT_MS, getMaxTextFileSize, MAX_SEARCH_RESULTS, PARALLEL_CONCURRENCY, } from '../core/util.js';
+import { defineTool } from './define.js';
+const SearchAndReplaceInputSchema = z.strictObject({
+    path: OptionalPath.describe('File to rewrite, or directory to rewrite under. Omitting it targets the ENTIRE first allowed root — ' +
+        'scope it deliberately, and pair a wide scope with dryRun=true first'),
+    pattern: SafeGlobPattern.optional().describe('Glob to restrict replacements to specific file types (e.g. **/*.ts); default: all text files'),
+    searchPattern: z
+        .string()
+        .min(1)
+        .max(10000)
+        .refine((val) => !isBlank(val), {
+        message: 'searchPattern cannot be empty or whitespace-only',
+    })
+        .describe('Exact literal text or RE2 regex pattern to search for. When isRegex=true, uses RE2 syntax (no lookahead, lookbehind, or backreferences are supported). Cannot be empty or whitespace-only.')
+        .meta({ examples: ['TODO', 'function\\s+(\\w+)', 'import.*from'] }),
+    replacement: z
+        .string()
+        .max(10000)
+        .describe('Replacement text. Use capture group references ($1, $2, etc.) when isRegex=true. Use an empty string to delete all matches.')
+        .meta({ examples: ['$1_renamed', '', 'TODO: fix'] }),
+    isRegex: defaultFalseBoolean('Treat searchPattern as a RE2 regex (default: literal text match)'),
+    includeHidden: includeHiddenField(),
+    includeIgnored: includeIgnoredField(),
+    caseSensitive: defaultFalseBoolean('Enable case-sensitive matching (default: case-insensitive)'),
+    wholeWord: defaultFalseBoolean('Match whole words only (word boundary anchoring)'),
+    dryRun: defaultFalseBoolean('Preview replacements without writing to disk (default: false = apply changes)'),
+    returnDiff: defaultFalseBoolean('Include a unified diff of all changes in the response'),
+    maxResults: z
+        .uint32()
+        .min(1)
+        .max(MAX_SEARCH_RESULTS)
+        .optional()
+        .default(DEFAULT_SEARCH_RESULTS)
+        .describe('Maximum total match count across all files before stopping'),
+    maxFiles: z
+        .uint32()
+        .min(1)
+        .max(MAX_SEARCH_RESULTS)
+        .optional()
+        .describe('Maximum number of files to process'),
+    maxDepth: maxDepthField(),
+});
+const ReplacePerPathSchema = z.strictObject({
+    path: z.string().describe('File path relative to the search root'),
+    value: z
+        .strictObject({ matches: NonNegInt.describe('Replacements applied in this file') })
+        .optional()
+        .describe('Replacement outcome; present on success'),
+    error: PerFileErrorSchema.optional().describe('Error details; present on failure'),
+});
+// The same `{ results, summary }` envelope `read`, `stat`, and `delete` use, so
+// a caller learns one shape for every tool that spans many paths. The former
+// `filesModified` / `failedFiles` counters are `summary.succeeded` / `.failed`,
+// and the old `primaryFile` block is gone — the resource_link content block
+// already points at the first modified file.
+const SearchAndReplaceOutputSchema = z.strictObject({
+    results: z
+        .array(ReplacePerPathSchema)
+        .describe('Per-file results: modified files, then any that could not be processed'),
+    summary: OperationSummarySchema,
+    totalMatches: NonNegInt.describe('Total number of replacements made across all files'),
+    filesScanned: NonNegInt.describe('Total number of files examined'),
+    resultsTruncated: z
+        .boolean()
+        .optional()
+        .describe('True when the results list holds fewer entries than summary.total: the changed-file or failed-file cap was hit. Trust summary over results.length.'),
+    diff: z
+        .string()
+        .optional()
+        .describe('Unified diff of all changes (present when returnDiff=true or dryRun=true)'),
+    diffTruncated: z
+        .boolean()
+        .optional()
+        .describe('True when the diff was cut due to the size limit'),
+    stoppedReason: StoppedReasonSchema.describe('Why enumeration stopped early: maxResults = match cap reached, maxFiles = file cap reached, timeout = time limit hit or cancelled. Absent when every matching file was enumerated. Marks the sweep incomplete, not the writes; files already dispatched still complete.'),
+});
 const MAX_FAILURES = 20;
 const REPLACE_CONCURRENCY = Math.min(PARALLEL_CONCURRENCY, 8);
 const MAX_CHANGED_FILES = 100;
@@ -37,53 +152,99 @@ function recordFailure(failures, failure) {
     failures.push(failure);
 }
 function recordChangedFile(summary, filePath, matchCount) {
-    const relativePath = relative(summary.root, filePath);
+    const relativePath = toPosixRelative(summary.root, filePath);
     if (summary.changedFiles.length < MAX_CHANGED_FILES) {
         summary.changedFiles.push({ path: relativePath, matches: matchCount });
         return;
     }
     summary.changedFilesTruncated = true;
 }
-function createRegexMatcher(pattern, caseSensitive) {
-    const flags = caseSensitive ? 'g' : 'gi';
-    try {
-        return new RE2(pattern, flags);
-    }
-    catch (error) {
-        throw new McpError(ErrorCode.INVALID_PATTERN, `Invalid regex pattern: ${formatUnknownErrorMessage(error)} (RE2: no lookahead/lookbehind/backrefs)`);
-    }
+const DOLLAR_TOKEN = /\$(\$|&|`|'|<([^>]*)>|\d{1,2})/g;
+/**
+ * Expand `$`-substitutions in a replacement template the way `RegExp` does.
+ *
+ * We cannot hand the template to RE2's own string replacer: it throws
+ * `Invalid replacement string` on any `$` not followed by a substitution it
+ * recognises (so a replacement of `$100` or a trailing `$` fails outright,
+ * where `RegExp` inserts the `$` literally), and it renders an out-of-range
+ * `$5` as `$4`. Passing a function to `String.replace` disables RE2's handling
+ * entirely, which leaves this the single owner of the syntax.
+ */
+function expandDollarTokens(template, match, groups, offset, input, named) {
+    return template.replace(DOLLAR_TOKEN, (token, kind, name) => {
+        if (kind === '$')
+            return '$';
+        if (kind === '&')
+            return match;
+        if (kind === '`')
+            return input.slice(0, offset);
+        if (kind === "'")
+            return input.slice(offset + match.length);
+        if (name !== undefined) {
+            if (named && Object.hasOwn(named, name))
+                return named[name] ?? '';
+            return token;
+        }
+        // `$12` prefers group 12, then falls back to group 1 followed by a literal
+        // `2`, and stays literal when neither exists — RegExp's own precedence.
+        const two = Number.parseInt(kind, 10);
+        if (kind.length === 2 && two >= 1 && two <= groups.length)
+            return groups[two - 1] ?? '';
+        const one = Number.parseInt(kind.slice(0, 1), 10);
+        if (one >= 1 && one <= groups.length) {
+            return (groups[one - 1] ?? '') + (kind.length === 2 ? kind.slice(1) : '');
+        }
+        return token;
+    });
 }
-function createRegexReplacementMatcher(regex) {
+function createRegexReplacementMatcher(regex, expandReplacement) {
     return {
         testBuffer(buffer) {
-            return regex.test(buffer);
+            // The regex is global and shared across every file in the batch, so a
+            // previous file's match would otherwise start this scan mid-string.
+            regex.lastIndex = 0;
+            return regex.test(buffer.toString('utf-8'));
         },
         count(content) {
             regex.lastIndex = 0;
             let matchCount = 0;
-            while (regex.exec(content) !== null) {
+            let m;
+            while ((m = regex.exec(content)) !== null) {
                 matchCount++;
-                if (regex.lastIndex === 0) {
+                // Treat an absent group 0 as zero-length: not bumping lastIndex here
+                // would spin forever.
+                if ((m[0]?.length ?? 0) === 0)
                     regex.lastIndex++;
-                }
             }
             return matchCount;
         },
         replace(content, replacement) {
             regex.lastIndex = 0;
-            return content.replace(regex, replacement);
+            // Only isRegex=true opts into $1/$& substitution. A literal search reaches
+            // this matcher too (case-insensitive and wholeWord both need a regex), and
+            // there the replacement must be inserted verbatim.
+            if (!expandReplacement)
+                return content.replace(regex, () => replacement);
+            return content.replace(regex, (match, ...rest) => {
+                // In ECMAScript/RE2, trailing arguments are [offset, input] or [offset, input, namedGroups].
+                const named = rest.length >= 3 && typeof rest[rest.length - 3] === 'number'
+                    ? rest.pop()
+                    : undefined;
+                const input = rest.pop();
+                const offset = rest.pop();
+                return expandDollarTokens(replacement, match, rest, offset, input, named);
+            });
+        },
+        dispose() {
+            freeRegex(regex);
         },
     };
 }
-function createLiteralReplacementMatcher(searchPattern, caseSensitive) {
+function createCaseSensitiveLiteralMatcher(searchPattern) {
     const patternLength = searchPattern.length;
-    const searchBuffer = caseSensitive
-        ? Buffer.from(searchPattern, 'utf8')
-        : null;
+    const searchBuffer = Buffer.from(searchPattern, 'utf8');
     return {
         testBuffer(buffer) {
-            if (!searchBuffer)
-                return true;
             return buffer.indexOf(searchBuffer) !== -1;
         },
         count(content) {
@@ -98,6 +259,9 @@ function createLiteralReplacementMatcher(searchPattern, caseSensitive) {
         replace(content, replacement) {
             return content.replaceAll(searchPattern, () => replacement);
         },
+        dispose() {
+            // no compiled pattern to release
+        },
     };
 }
 function buildReplacementPlan(content, replacement, matcher) {
@@ -111,28 +275,22 @@ function buildReplacementPlan(content, replacement, matcher) {
         updatedContent: matcher.replace(content, replacement),
     };
 }
-function formatFileTooLargeError(filePath, size, maxFileSize) {
-    return `File too large: ${filePath} (${size} bytes > ${maxFileSize} bytes)`;
-}
 async function processEntry(entryPath, ctx) {
     const { options, signal, summary } = ctx;
-    let validPath;
-    try {
-        validPath = await validatePathForWrite(entryPath, signal);
-    }
-    catch (error) {
-        summary.failedFiles++;
-        recordFailure(summary.failures, {
-            path: entryPath,
-            error: buildStructuredError(error, ErrorCode.UNKNOWN, entryPath),
-        });
-        return;
-    }
+    const validPath = entryPath;
     try {
         const plan = await readReplacementPlan(validPath, ctx);
         if (!plan) {
             return;
         }
+        if (!options.dryRun) {
+            await ctx.fs.writeFile(entryPath, plan.updatedContent, {
+                encoding: 'utf-8',
+                signal,
+            });
+        }
+        // Bookkeep only after the write succeeds (or in dryRun, where there is no
+        // write): a failed write must not count the file as changed.
         summary.totalMatches += plan.matchCount;
         summary.filesChanged++;
         recordChangedFile(summary, validPath, plan.matchCount);
@@ -141,109 +299,62 @@ async function processEntry(entryPath, ctx) {
             originalContent: plan.originalContent,
             updatedContent: plan.updatedContent,
             includeDiff: options.dryRun || options.returnDiff,
+            ...(signal ? { signal } : {}),
         });
-        if (!options.dryRun) {
-            await atomicWriteFile(validPath, plan.updatedContent, {
-                encoding: 'utf-8',
-                signal,
-            });
-        }
     }
     catch (error) {
         summary.failedFiles++;
         recordFailure(summary.failures, {
-            path: validPath,
-            error: buildStructuredError(error, ErrorCode.UNKNOWN, validPath),
+            path: toPosixRelative(summary.root, validPath),
+            error: Problem.fromUnknown(error, ErrorCode.UNKNOWN, validPath),
         });
     }
 }
 async function readReplacementPlan(validPath, ctx) {
-    const { matcher, replacement, maxFileSize, signal } = ctx;
-    let fileHandle;
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const fd = await open(validPath, 'r');
-        fileHandle = fd;
+        const { matcher, replacement, maxFileSize, signal } = ctx;
+        const fileHandle = __addDisposableResource(env_1, await ctx.fs.open(validPath, 'r'), true);
         const stats = await fileHandle.stat();
         if (stats.size > maxFileSize) {
-            throw new Error(formatFileTooLargeError(validPath, stats.size, maxFileSize));
+            throw new FsError(ErrorCode.TOO_LARGE, `File too large: ${validPath} (${String(stats.size)} bytes > ${String(maxFileSize)} bytes)`);
         }
-        let content;
-        if (matcher.testBuffer) {
-            const buffer = await fileHandle.readFile({ signal });
-            if (!matcher.testBuffer(buffer)) {
-                return undefined;
-            }
-            content = buffer.toString('utf-8');
-        }
-        else {
-            content = await fileHandle.readFile({
-                encoding: 'utf-8',
-                signal,
-            });
-        }
-        return buildReplacementPlan(content, replacement, matcher);
+        const buffer = await readFileBufferWithLimit(fileHandle, maxFileSize, validPath, signal);
+        if (!matcher.testBuffer(buffer))
+            return undefined;
+        return buildReplacementPlan(buffer.toString('utf-8'), replacement, matcher);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
     }
     finally {
-        if (fileHandle) {
-            await fileHandle.close();
-        }
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
     }
 }
 async function maybeAppendPatchDiff(summary, params) {
     if (!params.includeDiff)
         return;
+    const header = toPosixRelative(summary.root, params.filePath);
+    const patch = await new Promise((resolve) => {
+        createTwoFilesPatch(header, header, params.originalContent, params.updatedContent, 'Original', 'Modified', {
+            callback: (res) => {
+                resolve(res ?? '');
+            },
+        });
+    });
     if (summary.diff.length >= MAX_DIFF_SIZE) {
         summary.diffTruncated = true;
         return;
     }
-    const patch = await new Promise((resolve) => {
-        // Defer to event loop to avoid blocking on large diffs
-        setImmediate(() => {
-            createTwoFilesPatch(basename(params.filePath), 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) {
+    if (summary.diff.length + patch.length <= MAX_DIFF_SIZE + DIFF_APPEND_BUFFER) {
         summary.diff += patch;
         return;
     }
     summary.diffTruncated = true;
 }
-async function processEntriesConcurrently(entries, options) {
-    const pending = new Set();
-    const { signal, concurrency, maxEntries, onEntry, runEntry } = options;
-    let dispatched = 0;
-    let stoppedByLimit = false;
-    const waitForSlot = async () => {
-        if (pending.size < concurrency)
-            return;
-        await Promise.race(pending);
-    };
-    for await (const entry of entries) {
-        if (signal?.aborted)
-            break;
-        if (maxEntries !== undefined && dispatched >= maxEntries) {
-            stoppedByLimit = true;
-            break;
-        }
-        await waitForSlot();
-        onEntry();
-        dispatched++;
-        const task = runEntry(entry.path);
-        pending.add(task);
-        void task.finally(() => {
-            pending.delete(task);
-        });
-    }
-    if (pending.size > 0) {
-        await Promise.allSettled([...pending]);
-    }
-    return { stoppedByLimit };
-}
 function createReplaceSummary(root) {
     return {
         root,
@@ -258,144 +369,204 @@ function createReplaceSummary(root) {
         diffTruncated: false,
     };
 }
-async function resolveSearchRoot(pathValue, signal) {
-    return pathValue
-        ? validateExistingPath(pathValue, signal)
-        : resolvePathOrRoot(pathValue);
-}
-function createReplacementRegex(args) {
-    if (!args.isRegex)
-        return undefined;
-    return createRegexMatcher(args.searchPattern, args.caseSensitive);
-}
-function createReplacementMatcher(args) {
-    const regex = createReplacementRegex(args);
-    if (regex) {
-        return createRegexReplacementMatcher(regex);
+async function resolveSearchRoot(pathValue, fs) {
+    if (!pathValue) {
+        return { root: fs.pathGuard.resolvePathOrRoot(undefined) };
     }
-    if (!args.caseSensitive) {
-        const escaped = args.searchPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const caseInsensitiveRegex = new RE2(escaped, 'gi');
-        return createRegexReplacementMatcher(caseInsensitiveRegex);
+    const resolvedPath = await fs.pathGuard.validateExistingPath(pathValue);
+    const { stats: fileStats } = await fs.stat(resolvedPath);
+    if (fileStats.isFile()) {
+        // A single explicit file target bypasses the glob machinery entirely:
+        // routing it through globEntries with baseNameMatch would rewrite the
+        // escaped basename to `**/${basename}` and match every same-named file
+        // under the parent tree, not just this one.
+        return {
+            root: dirname(resolvedPath),
+            singleFile: resolvedPath,
+        };
     }
-    return createLiteralReplacementMatcher(args.searchPattern, args.caseSensitive);
+    return { root: resolvedPath };
 }
-async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
-    const maxFileSize = MAX_TEXT_FILE_SIZE;
-    const root = await resolveSearchRoot(args.path, signal);
-    const matcher = createReplacementMatcher(args);
-    const entries = globEntries({
-        cwd: root,
-        pattern: args.filePattern,
-        excludePatterns: args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS,
-        includeHidden: args.includeHidden,
-        baseNameMatch: false,
-        caseSensitiveMatch: true, // Default to sensitive for file paths
-        followSymbolicLinks: false,
-        onlyFiles: true,
-        stats: false,
-        suppressErrors: true,
-    });
-    const summary = createReplaceSummary(root);
-    const t0 = performance.now();
-    const context = {
-        options: {
-            dryRun: args.dryRun,
-            returnDiff: args.returnDiff,
-        },
-        replacement: args.replacement,
-        matcher,
-        maxFileSize,
-        signal,
-        summary,
-    };
-    const { stoppedByLimit } = await processEntriesConcurrently(entries, {
-        signal,
-        concurrency: REPLACE_CONCURRENCY,
-        ...(args.maxFiles !== undefined ? { maxEntries: args.maxFiles } : {}),
-        onEntry: () => {
-            summary.processedFiles++;
-            onProgress({ current: summary.processedFiles });
-        },
-        runEntry: (entryPath) => processEntry(entryPath, context),
-    });
-    summary.perfTimeMs = performance.now() - t0;
-    if (stoppedByLimit) {
-        summary.stoppedReason = 'maxFiles';
-    }
-    onProgress({ current: summary.processedFiles });
-    if (!args.dryRun && summary.totalMatches > 0) {
-        Logger.info(`search_and_replace: ${summary.filesChanged} file(s), ${summary.totalMatches} match(es)`);
+function buildSearchPattern(args) {
+    if (args.isRegex) {
+        return args.wholeWord ? `\\b(?:${args.searchPattern})\\b` : args.searchPattern;
     }
-    return buildToolResponse(buildSearchAndReplaceText(summary, args.dryRun), buildSearchAndReplaceStructuredResult(summary, args));
-}
-export function registerSearchAndReplaceTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'search_and_replace',
-        ctx,
-        outputSchema: SearchAndReplaceOutputSchema,
-        timedSignal: {},
-        ...(args.path ? { context: { path: args.path } } : {}),
-        run: async (signal) => {
-            const dryLabel = args.dryRun ? ' [dry run]' : '';
-            const truncatedPattern = truncateProgressPattern(args.searchPattern);
-            const context = `"${truncatedPattern}" in ${args.filePattern}${dryLabel}`;
-            const progress = createToolProgressSession(ctx, `${SEARCH_AND_REPLACE_TOOL.title}: ${context}`);
-            const progressWithMessage = ({ current, total, }) => {
-                progress.update({
-                    current,
-                    ...(total !== undefined ? { total } : {}),
-                    message: `${SEARCH_AND_REPLACE_TOOL.title}: ${truncatedPattern} [${current} files]`,
-                });
-            };
-            try {
-                const result = await handleSearchAndReplace(args, signal, progressWithMessage);
-                const sc = result.structuredContent;
-                const finalCurrent = resolveFinalProgressCurrent(progress, (sc.processedFiles ?? 0) + 1);
-                const matchWord = (sc.matches ?? 0) === 1 ? 'match' : 'matches';
-                const fileWord = (sc.filesChanged ?? 0) === 1 ? 'file' : 'files';
-                let endSuffix = `${sc.matches ?? 0} ${matchWord} in ${sc.filesChanged ?? 0} ${fileWord}`;
-                if (sc.failedFiles)
-                    endSuffix += `, ${sc.failedFiles} failed`;
-                progress.complete(`${SEARCH_AND_REPLACE_TOOL.title}: ${context} • ${endSuffix}`, finalCurrent);
-                if (!args.dryRun) {
-                    void ctx.log?.('info', `search_and_replace: ${String(sc.matches ?? 0)} matches in ${String(sc.filesChanged ?? 0)} files`);
-                }
-                return result;
-            }
-            catch (error) {
-                progress.fail(`${SEARCH_AND_REPLACE_TOOL.title}: ${context} • ${classifyError(error)}`);
-                throw error;
-            }
-        },
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
-    });
-    registerStandardTool(server, SEARCH_AND_REPLACE_TOOL, handler, options);
+    const escaped = escapeRegexLiteral(args.searchPattern);
+    return args.wholeWord ? `\\b(?:${escaped})\\b` : escaped;
 }
-function buildSearchAndReplaceText(summary, dryRun) {
-    const failureSuffix = summary.failedFiles > 0 ? ` (${summary.failedFiles} failed)` : '';
-    const dryRunSuffix = dryRun ? ' (Dry run)' : '';
-    const timing = summary.perfTimeMs
-        ? ` [\u23F1\uFE0F ${summary.perfTimeMs.toFixed(0)}ms]`
-        : '';
-    return `Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${dryRunSuffix}${timing}`;
+function createReplacementMatcher(args) {
+    // Use regex when isRegex, wholeWord, or case-insensitive (all require RE2)
+    if (args.isRegex || args.wholeWord || !args.caseSensitive) {
+        const regex = compileRegex(buildSearchPattern(args), { caseSensitive: args.caseSensitive });
+        return createRegexReplacementMatcher(regex, args.isRegex);
+    }
+    return createCaseSensitiveLiteralMatcher(args.searchPattern);
 }
 function buildSearchAndReplaceStructuredResult(summary, args) {
+    const results = [
+        ...summary.changedFiles.map((f) => ({ path: f.path, value: { matches: f.matches } })),
+        ...summary.failures.map((f) => ({ path: f.path, error: f.error })),
+    ];
     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 }
+        results,
+        // `failedFiles` counts every failure; `failures` itself is capped at
+        // MAX_FAILURES, so the summary must not be derived from the array length.
+        summary: {
+            total: summary.filesChanged + summary.failedFiles,
+            succeeded: summary.filesChanged,
+            failed: summary.failedFiles,
+        },
+        totalMatches: summary.totalMatches,
+        filesScanned: summary.processedFiles,
+        // Failures are capped at MAX_FAILURES independently of the changed-file
+        // cap, so either cap can leave `results` shorter than `summary.total`.
+        ...(summary.changedFilesTruncated || summary.failures.length < summary.failedFiles
+            ? { resultsTruncated: true }
             : {}),
+        ...((args.dryRun || args.returnDiff) && summary.diff ? { diff: summary.diff } : {}),
         ...(summary.diffTruncated ? { diffTruncated: true } : {}),
         ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
     };
 }
+async function handleSearchAndReplace(args, ctx) {
+    const maxFileSize = getMaxTextFileSize();
+    const { root, singleFile } = await resolveSearchRoot(args.path, ctx.fs);
+    const effectivePattern = args.pattern ?? '**/*';
+    // An explicit single-file target bypasses baseNameMatch/exclude/hidden/
+    // gitignore filtering — it should always be processed as the one file named.
+    // The async generator matches globEntries' AsyncIterable contract; it needs
+    // no await (single yield), hence the disable.
+    const entries = singleFile
+        ? // eslint-disable-next-line @typescript-eslint/require-await
+            (async function* singleFileEntry() {
+                yield { path: singleFile };
+            })()
+        : globEntries({
+            cwd: root,
+            pattern: effectivePattern,
+            excludePatterns: args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS,
+            includeHidden: args.includeHidden,
+            respectGitignore: !args.includeIgnored,
+            baseNameMatch: true,
+            onlyFiles: true,
+            suppressErrors: true,
+            ...(args.maxDepth !== undefined ? { maxDepth: args.maxDepth } : {}),
+        });
+    const summary = createReplaceSummary(root);
+    // The matcher may own a compiled RE2 pattern, whose wasm memory re2-wasm
+    // never reclaims on its own. Nothing past the scan touches it, so free it the
+    // moment the scan is done — success, failure, or abort alike.
+    const matcher = createReplacementMatcher(args);
+    let scan;
+    try {
+        const context = {
+            options: {
+                dryRun: args.dryRun,
+                returnDiff: args.returnDiff,
+            },
+            replacement: args.replacement,
+            matcher,
+            maxFileSize,
+            signal: ctx.signal,
+            summary,
+            fs: ctx.fs,
+        };
+        scan = await processEntriesConcurrently(entries, {
+            signal: ctx.signal,
+            concurrency: REPLACE_CONCURRENCY,
+            ...(args.maxFiles !== undefined ? { maxEntries: args.maxFiles } : {}),
+            shouldStop: () => summary.totalMatches >= args.maxResults,
+            onEntry: () => {
+                summary.processedFiles++;
+                ctx.onProgress?.({ current: summary.processedFiles });
+            },
+            onError: (entryPath, err) => {
+                summary.failedFiles++;
+                recordFailure(summary.failures, {
+                    path: toPosixRelative(summary.root, entryPath),
+                    error: Problem.fromUnknown(err, ErrorCode.UNKNOWN, entryPath),
+                });
+            },
+            runEntry: (entryPath) => processEntry(entryPath, context),
+        });
+    }
+    finally {
+        matcher.dispose();
+    }
+    const stoppedReason = scan.resolve();
+    if (stoppedReason !== undefined)
+        summary.stoppedReason = stoppedReason;
+    ctx.onProgress?.({ current: summary.processedFiles });
+    if (!args.dryRun && summary.totalMatches > 0) {
+        ctx.log?.('info', `${summary.filesChanged} file(s) changed, ${summary.totalMatches} match(es)`, 'replace_text');
+    }
+    const structured = buildSearchAndReplaceStructuredResult(summary, args);
+    // Store primary file in resource store if available (skip in dryRun to avoid reading stale disk content)
+    if (!args.dryRun &&
+        ctx.resourceStore &&
+        summary.changedFiles.length > 0 &&
+        summary.filesChanged > 0) {
+        const primaryFile = summary.changedFiles[0];
+        if (!primaryFile)
+            return { structured };
+        const primaryFilePath = primaryFile.path;
+        const fullPath = join(summary.root, primaryFilePath);
+        try {
+            const { content: rawBuffer } = await ctx.fs.readRaw(fullPath, {
+                signal: ctx.signal,
+            });
+            const mimeInfo = detectMimeFromContent(fullPath, rawBuffer.toString('utf-8'));
+            const link = buildFileResourceLink(fullPath, mimeInfo.mimeType, rawBuffer.length);
+            return { structured, link };
+        }
+        catch (error) {
+            rethrowIfAborted(error);
+            // Gracefully fall back if resource storage fails
+            ctx.log?.('error', `Failed to store primary file in resource store: ${formatUnknownErrorMessage(error)}`, 'replace_text');
+        }
+    }
+    return { structured };
+}
+export const SEARCH_AND_REPLACE = defineTool({
+    name: 'replace_text',
+    title: 'Search and Replace',
+    description: 'Bulk search-and-replace across files matching a glob pattern. ' +
+        'Replaces ALL occurrences per file (unlike edit, which replaces only the first match). ' +
+        'Set returnDiff=true to preview changes as a unified diff before or after writing. ' +
+        'Literal matching by default; set isRegex=true to enable RE2 regex with capture groups ($1, $2).',
+    input: SearchAndReplaceInputSchema,
+    output: SearchAndReplaceOutputSchema,
+    // results[].value XOR results[].error, and `summary` counts files while
+    // `totalMatches` counts replacements — not inferable from the description.
+    publishOutputSchema: true,
+    annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+    },
+    timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
+    defaultErrorCode: ErrorCode.UNKNOWN,
+    progress: (args) => {
+        const dryLabel = args.dryRun ? ' [dry run]' : '';
+        return {
+            label: `Replace${dryLabel}`,
+            subject: `${truncateProgressPattern(args.searchPattern)} → ${truncateProgressPattern(args.replacement)}`,
+        };
+    },
+    accessPaths: (args) => (args.path ? [args.path] : []),
+    run: async (args, ctx) => {
+        const truncatedPattern = truncateProgressPattern(args.searchPattern);
+        const { structured, link } = await handleSearchAndReplace(args, ctx);
+        const dryLabel = args.dryRun ? ' [dry run]' : '';
+        const summaryText = `replace_text: '${truncatedPattern}'${dryLabel}` +
+            ` \u00b7 ${String(structured.totalMatches)} match(es)` +
+            ` in ${String(structured.summary.succeeded)} file(s)` +
+            (structured.summary.failed > 0 ? ` \u00b7 ${String(structured.summary.failed)} failed` : '');
+        if (link) {
+            return { structured, text: summaryText, resources: [link] };
+        }
+        return { structured, text: summaryText };
+    },
+});
+//# sourceMappingURL=replace-in-files.js.map