@j0hanz/filesystem-mcp 1.10.0 → 1.11.1

package/dist/tools/edit-file.js

@@ -20,11 +20,23 @@ export const EDIT_FILE_TOOL = {
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
     nuances: ['Each edit applies to the output of the previous edit.'],
     gotchas: ['Unmatched `oldText` entries listed in `unmatchedEdits`.'],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+function computeDiffStats(original, modified) {
+    const patch = createTwoFilesPatch('a', 'b', original, modified);
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const line of patch.split('\n')) {
+        if (line.startsWith('+') && !line.startsWith('+++'))
+            linesAdded++;
+        else if (line.startsWith('-') && !line.startsWith('---'))
+            linesRemoved++;
+    }
+    return { linesAdded, linesRemoved };
+}
 function applyEdits(content, edits, ignoreWhitespace) {
     let newContent = content;
     let appliedEdits = 0;
@@ -74,10 +86,15 @@ function applyEdits(content, edits, ignoreWhitespace) {
             appliedEdits += 1;
         }
     }
+    const { linesAdded, linesRemoved } = appliedEdits > 0
+        ? computeDiffStats(content, newContent)
+        : { linesAdded: 0, linesRemoved: 0 };
     const result = {
         content: newContent,
         appliedEdits,
         unmatchedEdits,
+        linesAdded,
+        linesRemoved,
     };
     if (minLine !== undefined && maxLine !== undefined) {
         result.lineRange = [minLine, maxLine];
@@ -92,11 +109,12 @@ export async function handleEditFile(args, signal) {
         throw new McpError(ErrorCode.E_TOO_LARGE, `File too large for edit: ${args.path} (${stats.size} bytes > ${MAX_TEXT_FILE_SIZE} bytes)`, args.path, { size: stats.size, maxFileSize: MAX_TEXT_FILE_SIZE });
     }
     const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });
-    const { content: newContent, appliedEdits, unmatchedEdits, lineRange, } = applyEdits(content, args.edits, args.ignoreWhitespace);
+    const { content: newContent, appliedEdits, unmatchedEdits, linesAdded, linesRemoved, lineRange, } = applyEdits(content, args.edits, args.ignoreWhitespace);
     const structured = {
         ok: true,
         path: validPath,
         appliedEdits,
+        ...(appliedEdits > 0 ? { linesAdded, linesRemoved } : {}),
         ...(unmatchedEdits.length > 0 ? { unmatchedEdits } : {}),
         ...(lineRange ? { lineRange } : {}),
     };
@@ -132,9 +150,8 @@ export function registerEditFileTool(server, options = {}) {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const name = path.basename(args.path);
-            const count = args.edits.length;
             const tag = args.dryRun ? ' [dry run]' : '';
-            return `🛠 edit: ${name} [${count} ${count === 1 ? 'edit' : 'edits'}]${tag}`;
+            return `🛠 edit: ${name}${tag}`;
         },
         completionMessage: (args, result) => {
             const name = path.basename(args.path);
@@ -144,12 +161,12 @@ export function registerEditFileTool(server, options = {}) {
             if (!sc.ok)
                 return `🛠 edit: ${name} • failed`;
             const applied = sc.appliedEdits ?? 0;
-            const unmatched = sc.unmatchedEdits?.length ?? 0;
+            if (applied === 0)
+                return `🛠 edit: ${name} • no changes`;
+            const added = sc.linesAdded ?? 0;
+            const removed = sc.linesRemoved ?? 0;
             const dry = args.dryRun ? 'dry run — ' : '';
-            if (unmatched > 0) {
-                return `🛠 edit: ${name} • ${dry}${applied} applied, ${unmatched} unmatched`;
-            }
-            return `🛠 edit: ${name} • ${dry}${applied} applied`;
+            return `🛠 edit: ${name} • ${dry} +${added} -${removed}`;
         },
     });
     const validatedHandler = withValidatedArgs(EditFileInputSchema, wrappedHandler);

package/dist/tools/move-file.js

@@ -17,7 +17,7 @@ export const MOVE_FILE_TOOL = {
     gotchas: [
         'On POSIX, an existing destination is silently overwritten; on Windows, rename fails with EEXIST if destination exists.',
     ],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 export async function handleMoveFile(args, signal) {
     const sources = args.sources ?? (args.source ? [args.source] : []);
@@ -158,12 +158,12 @@ export function registerMoveFileTool(server, options = {}) {
                 const src = path.basename(args.source);
                 if (result.isError)
                     return `🛠 mv: ${src} → ${dest} • failed`;
-                return `🛠 mv: ${src} → ${dest} • moved`;
+                return `🛠 mv: ${src} → ${dest}`;
             }
             const count = (args.source ? 1 : 0) + (args.sources?.length ?? 0);
             if (result.isError)
                 return `🛠 mv: ${count} items → ${dest} • failed`;
-            return `🛠 mv: ${count} items → ${dest} • moved`;
+            return `🛠 mv: ${count} items → ${dest}`;
         },
     });
     const validatedHandler = withValidatedArgs(MoveFileInputSchema, wrappedHandler);

package/dist/tools/read-multiple.js

@@ -1,5 +1,5 @@
 import * as path from 'node:path';
-import { DEFAULT_READ_MANY_MAX_TOTAL_SIZE, DEFAULT_SEARCH_TIMEOUT_MS, } from '../lib/constants.js';
+import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { readMultipleFiles } from '../lib/file-operations/metadata.js';
 import { ReadMultipleFilesInputSchema, ReadMultipleFilesOutputSchema, } from '../schemas.js';
@@ -20,35 +20,81 @@ export const READ_MULTIPLE_FILES_TOOL = {
     ],
 };
 function toStructuredReadManyResult(result) {
-    const structured = {
+    return {
         path: result.path,
+        ...(result.content !== undefined ? { content: result.content } : {}),
+        ...(result.truncated ? { truncated: result.truncated } : {}),
+        ...(result.resourceUri ? { resourceUri: result.resourceUri } : {}),
+        ...(result.head !== undefined ? { head: result.head } : {}),
+        ...(result.tail !== undefined ? { tail: result.tail } : {}),
+        ...(result.startLine !== undefined ? { startLine: result.startLine } : {}),
+        ...(result.endLine !== undefined ? { endLine: result.endLine } : {}),
+        ...(result.hasMoreLines ? { hasMoreLines: result.hasMoreLines } : {}),
+        ...(result.totalLines !== undefined
+            ? { totalLines: result.totalLines }
+            : {}),
+        ...(result.linesRead !== undefined ? { linesRead: result.linesRead } : {}),
+        ...(result.truncationReason
+            ? { truncationReason: result.truncationReason }
+            : {}),
+        ...(result.error ? { error: result.error } : {}),
     };
-    if (result.content !== undefined)
-        structured.content = result.content;
-    if (result.truncated)
-        structured.truncated = result.truncated;
-    if (result.resourceUri)
-        structured.resourceUri = result.resourceUri;
-    if (result.head !== undefined)
-        structured.head = result.head;
-    if (result.tail !== undefined)
-        structured.tail = result.tail;
-    if (result.startLine !== undefined)
-        structured.startLine = result.startLine;
-    if (result.endLine !== undefined)
-        structured.endLine = result.endLine;
-    if (result.hasMoreLines)
-        structured.hasMoreLines = result.hasMoreLines;
-    if (result.totalLines !== undefined)
-        structured.totalLines = result.totalLines;
-    if (result.linesRead !== undefined)
-        structured.linesRead = result.linesRead;
-    if (result.truncationReason) {
-        structured.truncationReason = result.truncationReason;
+}
+function resolveReadManyTruncationReason(result) {
+    if (!result.truncated)
+        return undefined;
+    if (result.readMode === 'head')
+        return 'head';
+    if (result.readMode === 'tail')
+        return 'tail';
+    if (result.readMode === 'range')
+        return 'range';
+    return undefined;
+}
+function maybeExternalizeReadManyResult(result, resourceStore) {
+    const truncationReason = resolveReadManyTruncationReason(result);
+    const baseResult = {
+        ...result,
+        ...(truncationReason ? { truncationReason } : {}),
+    };
+    if (!result.content) {
+        return baseResult;
+    }
+    const externalized = maybeExternalizeTextContent(resourceStore, result.content, { name: `read:${path.basename(result.path)}`, mimeType: 'text/plain' });
+    if (!externalized) {
+        return baseResult;
     }
-    if (result.error)
-        structured.error = result.error;
-    return structured;
+    return {
+        ...baseResult,
+        content: externalized.preview,
+        truncated: true,
+        resourceUri: externalized.entry.uri,
+        truncationReason: 'externalized',
+    };
+}
+function buildReadManyResourceLinks(results) {
+    return results.flatMap((result) => {
+        if (!result.resourceUri)
+            return [];
+        return [
+            buildResourceLink({
+                uri: result.resourceUri,
+                name: `read:${path.basename(result.path)}`,
+                description: 'Full file contents',
+            }),
+        ];
+    });
+}
+function buildReadManyTextResult(results) {
+    return results
+        .map((result) => {
+        const header = `=== ${result.path} ===`;
+        if (result.error) {
+            return `${header}\nError: ${result.error}`;
+        }
+        return `${header}\n${result.content ?? ''}`;
+    })
+        .join('\n\n');
 }
 async function handleReadMultipleFiles(args, signal, resourceStore, onReadComplete) {
     const options = {
@@ -60,48 +106,9 @@ async function handleReadMultipleFiles(args, signal, resourceStore, onReadComple
         ...(onReadComplete ? { onReadComplete } : {}),
     };
     const results = await readMultipleFiles(args.paths, options);
-    const maxTotalSize = DEFAULT_READ_MANY_MAX_TOTAL_SIZE;
-    const mappedResults = results.map((result) => {
-        let baseTruncationReason;
-        if (result.truncated && result.readMode === 'head') {
-            baseTruncationReason = 'head';
-        }
-        else if (result.truncated && result.readMode === 'tail') {
-            baseTruncationReason = 'tail';
-        }
-        else if (result.truncated && result.readMode === 'range') {
-            baseTruncationReason = 'range';
-        }
-        const baseResult = {
-            ...result,
-            maxTotalSize,
-            ...(baseTruncationReason
-                ? { truncationReason: baseTruncationReason }
-                : {}),
-        };
-        if (!result.content) {
-            return baseResult;
-        }
-        const externalized = maybeExternalizeTextContent(resourceStore, result.content, { name: `read:${path.basename(result.path)}`, mimeType: 'text/plain' });
-        if (!externalized) {
-            return baseResult;
-        }
-        return {
-            ...baseResult,
-            content: externalized.preview,
-            truncated: true,
-            resourceUri: externalized.entry.uri,
-            truncationReason: 'externalized',
-        };
-    });
-    let succeeded = 0;
-    let failed = 0;
-    for (const result of mappedResults) {
-        if (result.error === undefined)
-            succeeded += 1;
-        else
-            failed += 1;
-    }
+    const mappedResults = results.map((result) => maybeExternalizeReadManyResult(result, resourceStore));
+    const succeeded = mappedResults.filter((r) => r.error === undefined).length;
+    const failed = mappedResults.length - succeeded;
     const structured = {
         ok: true,
         results: mappedResults.map((result) => toStructuredReadManyResult(result)),
@@ -111,26 +118,7 @@ async function handleReadMultipleFiles(args, signal, resourceStore, onReadComple
             failed,
         },
     };
-    const resourceLinks = [];
-    for (const result of mappedResults) {
-        if (!result.resourceUri)
-            continue;
-        resourceLinks.push(buildResourceLink({
-            uri: result.resourceUri,
-            name: `read:${path.basename(result.path)}`,
-            description: 'Full file contents',
-        }));
-    }
-    const text = mappedResults
-        .map((result) => {
-        const header = `=== ${result.path} ===`;
-        if (result.error) {
-            return `${header}\nError: ${result.error}`;
-        }
-        return `${header}\n${result.content ?? ''}`;
-    })
-        .join('\n\n');
-    return buildToolResponse(text, structured, resourceLinks);
+    return buildToolResponse(buildReadManyTextResult(mappedResults), structured, buildReadManyResourceLinks(mappedResults));
 }
 export function registerReadMultipleFilesTool(server, options = {}) {
     const handler = (args, extra) => {

package/dist/tools/read.js

@@ -18,7 +18,7 @@ export const READ_FILE_TOOL = {
     nuances: [
         'Large content is externalized to `filesystem-mcp://result/{id}` and preview is returned inline.',
     ],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 async function handleReadFile(args, signal, resourceStore) {
     const options = {

package/dist/tools/replace-in-files.d.ts

@@ -3,8 +3,11 @@ import type { z } from 'zod';
 import { SearchAndReplaceInputSchema, SearchAndReplaceOutputSchema } from '../schemas.js';
 import { type ToolContract, type ToolRegistrationOptions, type ToolResponse } from './shared.js';
 export declare const SEARCH_AND_REPLACE_TOOL: ToolContract;
-export declare function handleSearchAndReplace(args: z.infer<typeof SearchAndReplaceInputSchema>, signal?: AbortSignal, onProgress?: (progress: {
+type SearchAndReplaceArgs = z.infer<typeof SearchAndReplaceInputSchema>;
+type SearchAndReplaceOutput = z.infer<typeof SearchAndReplaceOutputSchema>;
+export declare function handleSearchAndReplace(args: SearchAndReplaceArgs, signal?: AbortSignal, onProgress?: (progress: {
     total?: number;
     current: number;
-}) => void): Promise<ToolResponse<z.infer<typeof SearchAndReplaceOutputSchema>>>;
+}) => void): Promise<ToolResponse<SearchAndReplaceOutput>>;
 export declare function registerSearchAndReplaceTool(server: McpServer, options?: ToolRegistrationOptions): void;
+export {};

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

@@ -94,6 +94,17 @@ function createLiteralReplacementMatcher(searchPattern, caseSensitive) {
     const replace = (content, replacement) => content.replaceAll(searchPattern, () => replacement);
     return { count, replace };
 }
+function buildReplacementPlan(content, replacement, matcher) {
+    const matchCount = matcher.count(content);
+    if (matchCount === 0) {
+        return undefined;
+    }
+    return {
+        matchCount,
+        originalContent: content,
+        updatedContent: matcher.replace(content, replacement),
+    };
+}
 function formatFileTooLargeError(filePath, size, maxFileSize) {
     return `File too large: ${filePath} (${size} bytes > ${maxFileSize} bytes)`;
 }
@@ -112,37 +123,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);
+        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,6 +156,17 @@ 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));
+    }
+    const content = await fs.readFile(validPath, {
+        encoding: 'utf-8',
+        signal: context.signal,
+    });
+    return buildReplacementPlan(content, context.replacement, context.matcher);
+}
 function maybeAppendPatchDiff(summary, params) {
     if (!params.includeDiff)
         return;
@@ -283,27 +297,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 +344,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) {

package/dist/tools/search-content.js

@@ -8,6 +8,11 @@ import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const MAX_INLINE_MATCHES = parseInt(process.env['FS_CONTEXT_MAX_INLINE_MATCHES'] ?? '', 10) || 50;
+const SEARCH_COMPLETION_REASON_LABELS = {
+    timeout: 'timeout',
+    maxResults: 'max results',
+    maxFiles: 'max files',
+};
 export const SEARCH_CONTENT_TOOL = {
     name: 'grep',
     title: 'Search Content',
@@ -26,20 +31,11 @@ export const SEARCH_CONTENT_TOOL = {
     ],
     taskSupport: 'optional',
 };
-function assertValidRegexPattern(pattern) {
+function findColumnOffset(content, pattern, matcher, caseSensitive) {
     try {
-        new RE2(pattern);
-    }
-    catch (error) {
-        throw new McpError(ErrorCode.E_INVALID_PATTERN, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
-    }
-}
-function findColumnOffset(content, pattern, isRegex, caseSensitive) {
-    try {
-        if (isRegex) {
-            const flags = caseSensitive ? '' : 'i';
-            const regex = new RE2(pattern, flags);
-            const match = regex.exec(content);
+        if (matcher) {
+            matcher.lastIndex = 0;
+            const match = matcher.exec(content);
             return match ? match.index : undefined;
         }
         if (caseSensitive) {
@@ -55,19 +51,21 @@ function findColumnOffset(content, pattern, isRegex, caseSensitive) {
         return undefined;
     }
 }
-function buildSearchTextResult(result, normalizedMatches) {
-    const { summary } = result;
+function buildSearchTextResult(heading, normalizedMatches, summary) {
     if (normalizedMatches.length === 0)
         return 'No matches';
-    let truncatedReason;
-    if (summary.truncated) {
-        truncatedReason = resolveTruncatedReason(summary);
+    const text = buildMatchListText(heading, normalizedMatches);
+    if (!summary) {
+        return text;
     }
+    const truncatedReason = summary.truncated
+        ? resolveTruncatedReason(summary)
+        : undefined;
     const summaryOptions = {
         truncated: summary.truncated,
         ...(truncatedReason ? { truncatedReason } : {}),
     };
-    return (buildMatchListText(`Found ${normalizedMatches.length}:`, normalizedMatches) + formatOperationSummary(summaryOptions));
+    return text + formatOperationSummary(summaryOptions);
 }
 function resolveTruncatedReason(summary) {
     if (summary.stoppedReason === 'timeout')
@@ -85,7 +83,7 @@ function buildMatchListText(heading, matches) {
     return joinLines(lines);
 }
 function buildSearchMatchPayload(match, context) {
-    const column = findColumnOffset(match.content, context.pattern, context.isRegex, context.caseSensitive);
+    const column = findColumnOffset(match.content, context.pattern, context.matcher, context.caseSensitive);
     return {
         file: match.relativeFile,
         line: match.line,
@@ -100,9 +98,10 @@ function formatSearchMatchLine(match) {
     const lineNum = String(match.line).padStart(4);
     return `  ${match.relativeFile}:${lineNum}: ${match.content}`;
 }
-function buildStructuredSearchResult(result, normalizedMatches, options, context) {
-    const { summary } = result;
-    const matches = normalizedMatches.map((match) => buildSearchMatchPayload(match, context));
+function buildSearchMatchPayloads(matches, context) {
+    return matches.map((match) => buildSearchMatchPayload(match, context));
+}
+function buildStructuredSearchResult(summary, matches, options) {
     return {
         ok: true,
         patternType: options.patternType,
@@ -155,8 +154,15 @@ async function handleSearchContent(args, signal, resourceStore, onProgress) {
     const basePath = resolvePathOrRoot(args.path);
     const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
     const patternType = args.isRegex ? 'regex' : 'literal';
+    let regexMatcher;
     if (args.isRegex) {
-        assertValidRegexPattern(args.pattern);
+        try {
+            const flags = (args.caseSensitive ? '' : 'i') + (args.multiline ? 'm' : '');
+            regexMatcher = new RE2(args.pattern, flags);
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.E_INVALID_PATTERN, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
+        }
     }
     const options = {
         includeHidden: args.includeHidden,
@@ -188,19 +194,20 @@ async function handleSearchContent(args, signal, resourceStore, onProgress) {
     const normalizedMatches = normalizeSearchMatches(result);
     const searchContext = {
         pattern: args.pattern,
-        isRegex: args.isRegex,
+        matcher: regexMatcher,
         caseSensitive: args.caseSensitive,
     };
-    const structuredFull = buildStructuredSearchResult(result, normalizedMatches, {
+    const matchPayloads = buildSearchMatchPayloads(normalizedMatches, searchContext);
+    const structuredFull = buildStructuredSearchResult(result.summary, matchPayloads, {
         patternType,
         caseSensitive: args.caseSensitive,
-    }, searchContext);
+    });
     const needsExternalize = normalizedMatches.length > MAX_INLINE_MATCHES;
     if (!resourceStore || !needsExternalize) {
-        return buildToolResponse(buildSearchTextResult(result, normalizedMatches), structuredFull);
+        return buildToolResponse(buildSearchTextResult(`Found ${normalizedMatches.length}:`, normalizedMatches, result.summary), structuredFull);
     }
     const previewMatches = normalizedMatches.slice(0, MAX_INLINE_MATCHES);
-    const previewPayload = previewMatches.map((match) => buildSearchMatchPayload(match, searchContext));
+    const previewPayload = buildSearchMatchPayloads(previewMatches, searchContext);
     const previewStructured = {
         ...structuredFull,
         matches: previewPayload,
@@ -213,7 +220,7 @@ async function handleSearchContent(args, signal, resourceStore, onProgress) {
         text: JSON.stringify(structuredFull),
     });
     previewStructured.resourceUri = entry.uri;
-    const text = buildMatchListText(`Found ${normalizedMatches.length} (showing first ${MAX_INLINE_MATCHES}):`, previewMatches);
+    const text = buildSearchTextResult(`Found ${normalizedMatches.length} (showing first ${MAX_INLINE_MATCHES}):`, previewMatches);
     return buildToolResponse(text, previewStructured, [
         buildResourceLink({
             uri: entry.uri,
@@ -263,22 +270,6 @@ export function registerSearchContentTool(server, options = {}) {
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path ?? '.'),
     });
-    function buildCompletionSuffix(params) {
-        if (params.count === 0) {
-            return `No matches in ${params.scope}`;
-        }
-        const matchWord = params.count === 1 ? 'match' : 'matches';
-        const fileWord = params.filesMatched === 1 ? 'file' : 'files';
-        const reasonLabels = {
-            timeout: 'timeout',
-            maxResults: 'max results',
-            maxFiles: 'max files',
-        };
-        const reasonSuffix = params.stoppedReason !== undefined
-            ? ` [${reasonLabels[params.stoppedReason]}]`
-            : '';
-        return `${params.count} ${matchWord} in ${params.filesMatched} ${fileWord}${reasonSuffix}`;
-    }
     const { isInitialized } = options;
     const wrappedHandler = wrapToolHandler(handler, {
         guard: isInitialized,
@@ -288,3 +279,14 @@ export function registerSearchContentTool(server, options = {}) {
         return;
     server.registerTool('grep', withDefaultIcons({ ...SEARCH_CONTENT_TOOL }, options.iconInfo), validatedHandler);
 }
+function buildCompletionSuffix(params) {
+    if (params.count === 0) {
+        return `No matches in ${params.scope}`;
+    }
+    const matchWord = params.count === 1 ? 'match' : 'matches';
+    const fileWord = params.filesMatched === 1 ? 'file' : 'files';
+    const reasonSuffix = params.stoppedReason !== undefined
+        ? ` [${SEARCH_COMPLETION_REASON_LABELS[params.stoppedReason]}]`
+        : '';
+    return `${params.count} ${matchWord} in ${params.filesMatched} ${fileWord}${reasonSuffix}`;
+}