@j0hanz/filesystem-mcp 1.11.1 → 1.12.0

package/dist/tools/apply-patch.js

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { readFile, stat } from 'node:fs/promises';
 import { applyPatch, parsePatch } from 'diff';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
@@ -29,15 +29,6 @@ function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
         return;
     throw new McpError(ErrorCode.E_TOO_LARGE, `File too large for patch: ${filePath} (${size} bytes > ${maxFileSize} bytes).`, filePath, { size, maxFileSize });
 }
-function assertPatchHasHunks(patch) {
-    if (!patch.trim()) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch content is empty.');
-    }
-    const hasHunk = /@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/u.test(patch);
-    if (!hasHunk) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch must include unified hunk headers (e.g., @@ -1,2 +1,2 @@).');
-    }
-}
 function countStructuredPatchStats(diff) {
     let linesAdded = 0;
     let linesRemoved = 0;
@@ -63,12 +54,12 @@ function extractPatchTargetPath(diff) {
         return stripGitPrefix(diff.oldFileName);
     return undefined;
 }
-async function applyPatchToFile(filePath, diff, options, signal) {
+async function applyDiff(filePath, diff, options, signal) {
     const validPath = await validateExistingPath(filePath, signal);
     assertAllowedFileAccess(filePath, validPath);
-    const stats = await withAbort(fs.stat(validPath), signal);
+    const stats = await withAbort(stat(validPath), signal);
     assertPatchTargetSizeWithinLimit(validPath, stats.size, MAX_TEXT_FILE_SIZE);
-    const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });
+    const content = await readFile(validPath, { encoding: 'utf-8', signal });
     const patched = applyPatch(content, diff, {
         fuzzFactor: options.fuzzFactor,
         autoConvertLineEndings: options.autoConvertLineEndings,
@@ -89,32 +80,31 @@ async function applyPatchToFile(filePath, diff, options, signal) {
     }
     return { path: validPath, applied: true, ...patchStats };
 }
-async function handleMultiFilePatch(basePath, parsed, options, signal) {
+async function processMultiFilePatch(basePath, parsed, options, signal) {
     const validBase = await validateExistingPath(basePath, signal);
-    const results = [];
-    for (const diff of parsed) {
+    const promises = parsed.map(async (diff) => {
         const fileName = extractPatchTargetPath(diff);
         if (!fileName) {
-            results.push({
+            return {
                 path: '<unknown>',
                 applied: false,
                 error: 'Missing file name in patch header',
-            });
-            continue;
+            };
         }
         const filePath = path.resolve(validBase, fileName);
         try {
-            const result = await applyPatchToFile(filePath, diff, options, signal);
-            results.push({ ...result, path: fileName });
+            const result = await applyDiff(filePath, diff, options, signal);
+            return { ...result, path: fileName };
         }
         catch (error) {
-            results.push({
+            return {
                 path: fileName,
                 applied: false,
                 error: formatUnknownErrorMessage(error),
-            });
+            };
         }
-    }
+    });
+    const results = await Promise.all(promises);
     const totals = results.reduce((acc, r) => {
         if (r.applied) {
             acc.applied++;
@@ -137,24 +127,28 @@ async function handleMultiFilePatch(basePath, parsed, options, signal) {
     });
 }
 async function handleApplyPatch(args, signal) {
-    assertPatchHasHunks(args.patch);
+    if (!args.patch.trim()) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch content is empty.');
+    }
     const fuzzFactor = args.fuzzFactor ?? 0;
     const parsed = parsePatch(args.patch);
+    const hasHunks = parsed.some((p) => p.hunks.length > 0);
+    if (!hasHunks) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch must include unified hunk headers (e.g., @@ -1,2 +1,2 @@).');
+    }
     const options = {
         dryRun: args.dryRun,
         fuzzFactor,
         autoConvertLineEndings: args.autoConvertLineEndings,
     };
-    // Multi-file patch: best-effort per file
     if (parsed.length > 1) {
-        return handleMultiFilePatch(args.path, parsed, options, signal);
+        return processMultiFilePatch(args.path, parsed, options, signal);
     }
-    // Single-file patch: delegate to shared helper, then assert success
     const diff = parsed[0];
     if (!diff) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'No patch content found.');
     }
-    const result = await applyPatchToFile(args.path, diff, options, signal);
+    const result = await applyDiff(args.path, diff, options, signal);
     if (!result.applied) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, result.error === 'Patch had no effect'
             ? 'Patch had no effect \u2014 the file content is unchanged after applying. The patch may not match the current file content. Generate a fresh patch via diff_files and retry.'
@@ -196,7 +190,7 @@ export function registerApplyPatchTool(server, options = {}) {
                 return `🛠 patch: ${name} • failed`;
             const added = sc.linesAdded ?? 0;
             const removed = sc.linesRemoved ?? 0;
-            const dry = args.dryRun ? 'dry run — ' : '';
+            const dry = args.dryRun ? 'dry run ' : '';
             if (added > 0 || removed > 0)
                 return `🛠 patch: ${name} • ${dry} +${added} -${removed}`;
             return `🛠 patch: ${name} • ${dry}no changes`;

package/dist/tools/calculate-hash.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
 import { PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations/core.js';
@@ -26,15 +27,9 @@ export const CALCULATE_HASH_TOOL = {
     taskSupport: 'optional',
 };
 async function hashFile(filePath, encoding, signal) {
-    assertNotAborted(signal);
-    const hashOp = createHash('sha256');
-    const stream = createReadStream(filePath, { signal });
-    for await (const chunk of stream) {
-        hashOp.update(chunk);
-        assertNotAborted(signal);
-    }
-    assertNotAborted(signal);
-    return encoding === undefined ? hashOp.digest() : hashOp.digest(encoding);
+    const hasher = createHash('sha256');
+    await pipeline(createReadStream(filePath, { signal, highWaterMark: 64 * 1024 }), hasher, { signal });
+    return encoding ? hasher.digest(encoding) : hasher.digest();
 }
 function toStableRelativePath(root, entryPath) {
     const relativePath = path.relative(root, entryPath);
@@ -84,25 +79,27 @@ async function hashDirectory(dirPath, options = {}) {
         });
     }
     assertNotAborted(signal);
-    // Phase 2: hash files concurrently with bounded pool.
     const concurrency = Math.min(PARALLEL_CONCURRENCY, 8);
     const entries = [];
     let filesHashed = 0;
     const totalFiles = filteredPaths.length;
-    for (let i = 0; i < filteredPaths.length; i += concurrency) {
-        assertNotAborted(signal);
-        const batch = filteredPaths.slice(i, i + concurrency);
-        const batchResults = await Promise.all(batch.map(async ({ filePath, relativePath }) => {
-            const fileHash = await hashFile(filePath, undefined, signal);
-            return { path: relativePath, hash: fileHash };
-        }));
-        entries.push(...batchResults);
-        filesHashed += batchResults.length;
-        reportPeriodicProgress(onProgress, filesHashed, {
-            throttleModulo: 25,
-            total: totalFiles,
-        });
-    }
+    const taskQueue = filteredPaths;
+    const worker = async () => {
+        while (taskQueue.length > 0) {
+            const task = taskQueue.pop();
+            if (!task)
+                break;
+            assertNotAborted(signal);
+            const fileHash = await hashFile(task.filePath, undefined, signal);
+            entries.push({ path: task.relativePath, hash: fileHash });
+            filesHashed++;
+            reportPeriodicProgress(onProgress, filesHashed, {
+                throttleModulo: 25,
+                total: totalFiles,
+            });
+        }
+    };
+    await Promise.all(Array.from({ length: concurrency }, () => worker()));
     reportPeriodicProgress(onProgress, filesHashed, {
         throttleModulo: 25,
         total: totalFiles,

package/dist/tools/diff-files.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { createTwoFilesPatch } from 'diff';
+import { formatPatch, structuredPatch } from 'diff';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
@@ -20,19 +20,18 @@ export const DIFF_FILES_TOOL = {
     gotchas: ['`isIdentical=true` means no hunks (`@@`) and empty diff.'],
     taskSupport: 'forbidden',
 };
-function computeDiffStats(patch) {
+function computeDiffStats(hunks) {
     let linesAdded = 0;
     let linesRemoved = 0;
-    let hunksCount = 0;
-    for (const line of patch.split('\n')) {
-        if (line.startsWith('@@'))
-            hunksCount++;
-        else if (line.startsWith('+') && !line.startsWith('+++'))
-            linesAdded++;
-        else if (line.startsWith('-') && !line.startsWith('---'))
-            linesRemoved++;
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            if (line.startsWith('+') && !line.startsWith('+++'))
+                linesAdded++;
+            else if (line.startsWith('-') && !line.startsWith('---'))
+                linesRemoved++;
+        }
     }
-    return { linesAdded, linesRemoved, hunksCount };
+    return { linesAdded, linesRemoved, hunksCount: hunks.length };
 }
 function assertDiffFileSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
@@ -55,14 +54,23 @@ async function handleDiffFiles(args, signal, resourceStore) {
         fs.readFile(originalPath, { encoding: 'utf-8', signal }),
         fs.readFile(modifiedPath, { encoding: 'utf-8', signal }),
     ]);
-    const patch = createTwoFilesPatch(path.basename(originalPath), path.basename(modifiedPath), originalContent, modifiedContent, undefined, undefined, {
-        ...(args.context !== undefined ? { context: args.context } : {}),
-        ignoreWhitespace: args.ignoreWhitespace,
-        stripTrailingCr: args.stripTrailingCr,
+    const patchObj = await new Promise((resolve) => {
+        structuredPatch(path.basename(originalPath), path.basename(modifiedPath), originalContent, modifiedContent, undefined, undefined, {
+            ...(args.context !== undefined ? { context: args.context } : {}),
+            ignoreWhitespace: args.ignoreWhitespace,
+            stripTrailingCr: args.stripTrailingCr,
+            timeout: 10000,
+            callback: (res) => {
+                resolve(res);
+            },
+        });
     });
-    const isIdentical = !patch.includes('@@');
-    const diffText = isIdentical ? '' : patch;
-    const stats = isIdentical ? undefined : computeDiffStats(patch);
+    if (!patchObj) {
+        throw new McpError(ErrorCode.E_TIMEOUT, `Diff computation timed out or failed due to complexity.`, originalPath);
+    }
+    const isIdentical = patchObj.hunks.length === 0;
+    const diffText = isIdentical ? '' : formatPatch(patchObj);
+    const stats = isIdentical ? undefined : computeDiffStats(patchObj.hunks);
     const externalized = maybeExternalizeTextContent(resourceStore, diffText, {
         name: 'diff:patch',
         mimeType: 'text/x-diff',

package/dist/tools/edit-file.d.ts

@@ -3,5 +3,8 @@ import type { z } from 'zod';
 import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
 import { type ToolContract, type ToolRegistrationOptions, type ToolResponse } from './shared.js';
 export declare const EDIT_FILE_TOOL: ToolContract;
-export declare function handleEditFile(args: z.infer<typeof EditFileInputSchema>, signal?: AbortSignal): Promise<ToolResponse<z.infer<typeof EditFileOutputSchema>>>;
+type EditInput = z.infer<typeof EditFileInputSchema>;
+type EditOutput = z.infer<typeof EditFileOutputSchema>;
+export declare function handleEditFile(args: EditInput, signal?: AbortSignal): Promise<ToolResponse<EditOutput>>;
 export declare function registerEditFileTool(server: McpServer, options?: ToolRegistrationOptions): void;
+export {};

package/dist/tools/edit-file.js

@@ -1,6 +1,6 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { createTwoFilesPatch } from 'diff';
+import { readFile, stat } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { createTwoFilesPatch, diffLines } from 'diff';
 import RE2 from 're2';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
@@ -13,7 +13,7 @@ export const EDIT_FILE_TOOL = {
     name: 'edit',
     title: 'Edit File',
     description: 'Apply sequential literal string replacements to a file (first occurrence per edit). ' +
-        '`oldText` must match exactly \u2014 include 3\u20135 lines of context for unique targeting. ' +
+        '`oldText` must match exactly — include 3–5 lines of context for unique targeting. ' +
         'Use `dryRun:true` to preview.',
     inputSchema: EditFileInputSchema,
     outputSchema: EditFileOutputSchema,
@@ -25,117 +25,186 @@ export const EDIT_FILE_TOOL = {
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+function getLineNumberAtIndex(str, maxIndex = str.length) {
+    let count = 1;
+    let pos = 0;
+    while (pos < maxIndex) {
+        pos = str.indexOf('\n', pos);
+        if (pos === -1 || pos >= maxIndex)
+            break;
+        count++;
+        pos++;
+    }
+    return count;
+}
+function countLines(str) {
+    return getLineNumberAtIndex(str);
+}
 function computeDiffStats(original, modified) {
-    const patch = createTwoFilesPatch('a', 'b', original, modified);
+    const changes = diffLines(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++;
+    for (const part of changes) {
+        if (part.added) {
+            linesAdded += part.count;
+        }
+        else if (part.removed) {
+            linesRemoved += part.count;
+        }
     }
     return { linesAdded, linesRemoved };
 }
-function applyEdits(content, edits, ignoreWhitespace) {
-    let newContent = content;
-    let appliedEdits = 0;
-    const unmatchedEdits = [];
-    let minLine;
-    let maxLine;
-    for (const edit of edits) {
-        if (ignoreWhitespace) {
-            const pattern = escapeRegExp(edit.oldText).replace(/\s+/g, '\\s+');
-            const regex = new RE2(pattern);
-            const match = regex.exec(newContent);
-            if (!match) {
-                unmatchedEdits.push(edit.oldText);
-                continue;
-            }
-            const { index } = match;
-            const matchLength = match[0].length;
-            const linesBefore = newContent.slice(0, index).split('\n').length;
-            const newTextLines = edit.newText.split('\n').length;
-            const startLine = linesBefore;
-            const endLine = linesBefore + newTextLines - 1;
-            if (minLine === undefined || startLine < minLine)
-                minLine = startLine;
-            if (maxLine === undefined || endLine > maxLine)
-                maxLine = endLine;
-            newContent =
-                newContent.slice(0, index) +
-                    edit.newText +
-                    newContent.slice(index + matchLength);
-            appliedEdits += 1;
-        }
-        else {
-            if (!newContent.includes(edit.oldText)) {
-                unmatchedEdits.push(edit.oldText);
-                continue;
-            }
-            const index = newContent.indexOf(edit.oldText);
-            const linesBefore = newContent.slice(0, index).split('\n').length;
-            const newTextLines = edit.newText.split('\n').length;
-            const startLine = linesBefore;
-            const endLine = linesBefore + newTextLines - 1;
-            if (minLine === undefined || startLine < minLine)
-                minLine = startLine;
-            if (maxLine === undefined || endLine > maxLine)
-                maxLine = endLine;
-            newContent = newContent.replace(edit.oldText, () => edit.newText);
-            appliedEdits += 1;
+function findEditMatch(content, oldText, ignoreWhitespace) {
+    if (ignoreWhitespace) {
+        const pattern = escapeRegExp(oldText).replace(/\s+/g, '\\s+');
+        const regex = new RE2(pattern);
+        const match = regex.exec(content);
+        if (!match) {
+            return undefined;
         }
+        return {
+            startIndex: match.index,
+            length: match[0].length,
+        };
+    }
+    const index = content.indexOf(oldText);
+    if (index === -1) {
+        return undefined;
+    }
+    return {
+        startIndex: index,
+        length: oldText.length,
+    };
+}
+function replaceEditMatch(content, match, newText) {
+    return (content.slice(0, match.startIndex) +
+        newText +
+        content.slice(match.startIndex + match.length));
+}
+function mergeLineRange(currentRange, content, matchStartIndex, newText) {
+    const startLine = getLineNumberAtIndex(content, matchStartIndex);
+    const endLine = startLine + countLines(newText) - 1;
+    if (!currentRange) {
+        return [startLine, endLine];
     }
+    return [
+        Math.min(currentRange[0], startLine),
+        Math.max(currentRange[1], endLine),
+    ];
+}
+function buildStructuredEditOutput(validPath, result) {
+    return {
+        ok: true,
+        path: validPath,
+        appliedEdits: result.appliedEdits,
+        ...(result.appliedEdits > 0
+            ? {
+                linesAdded: result.linesAdded,
+                linesRemoved: result.linesRemoved,
+            }
+            : {}),
+        ...(result.unmatchedEdits.length > 0
+            ? { unmatchedEdits: result.unmatchedEdits }
+            : {}),
+        ...(result.lineRange ? { lineRange: result.lineRange } : {}),
+    };
+}
+function finalizeEditResult(originalContent, updatedContent, appliedEdits, unmatchedEdits, lineRange) {
     const { linesAdded, linesRemoved } = appliedEdits > 0
-        ? computeDiffStats(content, newContent)
+        ? computeDiffStats(originalContent, updatedContent)
         : { linesAdded: 0, linesRemoved: 0 };
-    const result = {
-        content: newContent,
+    return {
+        content: updatedContent,
         appliedEdits,
         unmatchedEdits,
         linesAdded,
         linesRemoved,
+        ...(lineRange ? { lineRange } : {}),
     };
-    if (minLine !== undefined && maxLine !== undefined) {
-        result.lineRange = [minLine, maxLine];
+}
+function buildDiff(validPath, original, modified) {
+    const fileName = basename(validPath);
+    return createTwoFilesPatch(fileName, fileName, original, modified, 'Original', 'Modified');
+}
+function formatUnmatchedEditsNote(unmatchedEdits) {
+    if (unmatchedEdits.length === 0) {
+        return '';
     }
-    return result;
+    return ` — ${unmatchedEdits.length} unmatched: [${unmatchedEdits
+        .map((text) => JSON.stringify(text.length > 40 ? `${text.slice(0, 40)}…` : text))
+        .join(', ')}]`;
 }
-export async function handleEditFile(args, signal) {
-    const validPath = await validateExistingPath(args.path, signal);
-    assertAllowedFileAccess(args.path, validPath);
-    const stats = await withAbort(fs.stat(validPath), signal);
+function buildEditMessage(requestedPath, result) {
+    const unmatchedNote = formatUnmatchedEditsNote(result.unmatchedEdits);
+    if (result.appliedEdits === 0) {
+        return `No edits applied to ${requestedPath}${unmatchedNote}`;
+    }
+    return `Successfully applied ${result.appliedEdits} edits to ${requestedPath}${unmatchedNote}`;
+}
+async function loadEditableFile(requestedPath, signal) {
+    const validPath = await validateExistingPath(requestedPath, signal);
+    assertAllowedFileAccess(requestedPath, validPath);
+    const stats = await withAbort(stat(validPath), signal);
     if (stats.size > MAX_TEXT_FILE_SIZE) {
-        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 });
+        throw new McpError(ErrorCode.E_TOO_LARGE, `File too large for edit: ${requestedPath} (${stats.size} bytes > ${MAX_TEXT_FILE_SIZE} bytes)`, requestedPath, { size: stats.size, maxFileSize: MAX_TEXT_FILE_SIZE });
     }
-    const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });
-    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 } : {}),
-    };
+    const content = await readFile(validPath, { encoding: 'utf-8', signal });
+    return { validPath, content };
+}
+function buildEditProgressMessage(args) {
+    const name = basename(args.path);
+    const tag = args.dryRun ? ' [dry run]' : '';
+    return `🛠 edit: ${name}${tag}`;
+}
+function buildEditCompletionMessage(args, result) {
+    const name = basename(args.path);
+    if (result.isError)
+        return `🛠 edit: ${name} • failed`;
+    const { structuredContent } = result;
+    if (!structuredContent.ok)
+        return `🛠 edit: ${name} • failed`;
+    const applied = structuredContent.appliedEdits ?? 0;
+    if (applied === 0)
+        return `🛠 edit: ${name} • no changes`;
+    const added = structuredContent.linesAdded ?? 0;
+    const removed = structuredContent.linesRemoved ?? 0;
+    const dry = args.dryRun ? 'dry run ' : '';
+    return `🛠 edit: ${name} • ${dry}+${added} -${removed}`;
+}
+function applyEdits(content, edits, ignoreWhitespace) {
+    let newContent = content;
+    let appliedEdits = 0;
+    const unmatchedEdits = [];
+    let lineRange;
+    for (const edit of edits) {
+        const match = findEditMatch(newContent, edit.oldText, ignoreWhitespace);
+        if (!match) {
+            unmatchedEdits.push(edit.oldText);
+            continue;
+        }
+        lineRange = mergeLineRange(lineRange, newContent, match.startIndex, edit.newText);
+        newContent = replaceEditMatch(newContent, match, edit.newText);
+        appliedEdits += 1;
+    }
+    return finalizeEditResult(content, newContent, appliedEdits, unmatchedEdits, lineRange);
+}
+export async function handleEditFile(args, signal) {
+    const { validPath, content } = await loadEditableFile(args.path, signal);
+    const editResult = applyEdits(content, args.edits, args.ignoreWhitespace);
+    const structured = buildStructuredEditOutput(validPath, editResult);
     if (args.dryRun) {
-        if (appliedEdits > 0) {
-            structured.diff = createTwoFilesPatch(path.basename(validPath), path.basename(validPath), content, newContent, 'Original', 'Modified');
+        if (editResult.appliedEdits > 0) {
+            structured.diff = buildDiff(validPath, content, editResult.content);
         }
-        return buildToolResponse(`Dry run complete. ${appliedEdits} edits would be applied.`, structured);
+        return buildToolResponse(`Dry run complete. ${editResult.appliedEdits} edits would be applied.`, structured);
     }
-    if (appliedEdits > 0) {
-        await atomicWriteFile(validPath, newContent, { encoding: 'utf-8', signal });
+    if (editResult.appliedEdits > 0) {
+        await atomicWriteFile(validPath, editResult.content, {
+            encoding: 'utf-8',
+            signal,
+        });
     }
-    const unmatchedNote = unmatchedEdits.length > 0
-        ? ` — ${unmatchedEdits.length} unmatched: [${unmatchedEdits
-            .map((s) => JSON.stringify(s.length > 40 ? `${s.slice(0, 40)}\u2026` : s))
-            .join(', ')}]`
-        : '';
-    const message = appliedEdits === 0
-        ? `No edits applied to ${args.path}${unmatchedNote}`
-        : `Successfully applied ${appliedEdits} edits to ${args.path}${unmatchedNote}`;
-    return buildToolResponse(message, structured);
+    return buildToolResponse(buildEditMessage(args.path, editResult), structured);
 }
 export function registerEditFileTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({
@@ -148,26 +217,8 @@ export function registerEditFileTool(server, options = {}) {
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => {
-            const name = path.basename(args.path);
-            const tag = args.dryRun ? ' [dry run]' : '';
-            return `🛠 edit: ${name}${tag}`;
-        },
-        completionMessage: (args, result) => {
-            const name = path.basename(args.path);
-            if (result.isError)
-                return `🛠 edit: ${name} • failed`;
-            const sc = result.structuredContent;
-            if (!sc.ok)
-                return `🛠 edit: ${name} • failed`;
-            const applied = sc.appliedEdits ?? 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 — ' : '';
-            return `🛠 edit: ${name} • ${dry} +${added} -${removed}`;
-        },
+        progressMessage: buildEditProgressMessage,
+        completionMessage: buildEditCompletionMessage,
     });
     const validatedHandler = withValidatedArgs(EditFileInputSchema, wrappedHandler);
     if (registerToolTaskIfAvailable(server, 'edit', EDIT_FILE_TOOL, validatedHandler, options.iconInfo, options.isInitialized))