lonny-agent 0.2.3 → 0.2.6

package/dist/tools/edit.js

@@ -1,21 +1,163 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { DIFF_DELETE, DIFF_INSERT, diffLinesRaw } from 'jest-diff';
 import { fmtErr } from './errors.js';
-// ── ANSI colors for diff output ─────────────────────────────────────────
+// ── ANSI colors for terminal output ───────────────────────────────────────
 const DIFF_RED = '\x1b[38;2;255;80;80m';
 const DIFF_GREEN = '\x1b[38;2;0;200;100m';
+const DIFF_DIM = '\x1b[38;2;100;100;100m';
 const DIFF_RESET = '\x1b[0m';
-function generateDiff(oldStr, newStr) {
+// ── Colors for HTML output ────────────────────────────────────────────────
+const HTML_RED = '#ff5050';
+const HTML_GREEN = '#00c864';
+const HTML_DIM = '#888888';
+/** Build diagnostic JSON for error messages */
+function buildDiag(edit) {
+    return JSON.stringify({
+        file_path: edit.file_path,
+        old_string: edit.old_string,
+        new_string: edit.new_string,
+    });
+}
+/** Summarize raw input for error messages to avoid dumping huge strings into the LLM context. */
+function summarizeRawInput(rawInput) {
+    const s = JSON.stringify(rawInput);
+    if (s.length <= 500)
+        return s;
+    return `${s.slice(0, 500)}... [truncated, total ${s.length} chars]`;
+}
+/** Compute diff lines using jest-diff for proper line-level diffs */
+export function computeDiff(oldStr, newStr) {
     const oldLines = oldStr === '' ? [] : oldStr.split('\n');
-    const newLines = newStr.split('\n');
-    const lines = [];
-    for (const line of oldLines) {
-        lines.push(`  ${DIFF_RED}- ${line}${DIFF_RESET}`);
+    const newLines = newStr === '' ? [] : newStr.split('\n');
+    if (oldLines.length === 0 && newLines.length === 0)
+        return [];
+    const rawDiff = diffLinesRaw(oldLines, newLines);
+    return rawDiff.map(d => ({
+        type: d[0] === DIFF_DELETE
+            ? 'delete'
+            : d[0] === DIFF_INSERT
+                ? 'insert'
+                : 'equal',
+        content: d[1],
+    }));
+}
+/** Terminal renderer — unified-diff format with color */
+export function renderDiffTerminal(lines, startLineNum) {
+    if (lines.length === 0)
+        return '';
+    const output = [];
+    let oldLn = startLineNum ?? 1;
+    let newLn = startLineNum ?? 1;
+    for (const line of lines) {
+        if (line.type === 'delete') {
+            output.push(`  ${DIFF_RED}- ${oldLn}  ${line.content}${DIFF_RESET}`);
+            oldLn++;
+        }
+        else if (line.type === 'insert') {
+            output.push(`  ${DIFF_GREEN}+ ${newLn}  ${line.content}${DIFF_RESET}`);
+            newLn++;
+        }
+        else {
+            output.push(`  ${DIFF_DIM}  ${oldLn}  ${line.content}${DIFF_RESET}`);
+            oldLn++;
+            newLn++;
+        }
     }
-    for (const line of newLines) {
-        lines.push(`  ${DIFF_GREEN}+ ${line}${DIFF_RESET}`);
+    return output.join('\n');
+}
+/** HTML renderer for web output */
+export function renderDiffHtml(lines) {
+    if (lines.length === 0)
+        return '';
+    const output = [];
+    for (const line of lines) {
+        if (line.type === 'delete') {
+            output.push(`  <span style="color: ${HTML_RED};">- ${escapeHtml(line.content)}</span>`);
+        }
+        else if (line.type === 'insert') {
+            output.push(`  <span style="color: ${HTML_GREEN};">+ ${escapeHtml(line.content)}</span>`);
+        }
+        else {
+            output.push(`  <span style="color: ${HTML_DIM};">  ${escapeHtml(line.content)}</span>`);
+        }
     }
-    return lines.join('\n');
+    return output.join('\n');
+}
+/** Escape HTML special characters */
+export function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+/**
+ * Generate diff output using jest-diff.
+ * Returns terminal-colored unified-diff format with line numbers.
+ */
+export function generateDiff(oldStr, newStr, startLineNum) {
+    const lines = computeDiff(oldStr, newStr);
+    return renderDiffTerminal(lines, startLineNum);
+}
+/**
+ * Generate diff with surrounding context lines (1 before, 1 after)
+ * and line numbers. Context lines are extracted from the full file content.
+ */
+export function generateDiffWithContext(fullContent, oldStr, newStr, matchIndex, matchLength) {
+    // Calculate 1-based line number of the first matched line
+    const firstLineNum = fullContent.slice(0, matchIndex).split('\n').length;
+    const contentLines = fullContent.split('\n');
+    // Find 0-based line index where matchIndex falls
+    let charPos = 0;
+    let matchStartLineIdx = 0;
+    for (let i = 0; i < contentLines.length; i++) {
+        if (charPos <= matchIndex && matchIndex < charPos + contentLines[i].length + 1) {
+            matchStartLineIdx = i;
+            break;
+        }
+        charPos += contentLines[i].length + 1; // +1 for \n
+    }
+    // How many lines does oldStr span in the original content?
+    const oldLines = oldStr === '' ? [] : oldStr.split('\n');
+    const oldLineCount = oldLines.length;
+    const matchEndLineIdx = matchStartLineIdx + oldLineCount - 1;
+    // Context before (1 line) and after (1 line)
+    const beforeLineIdx = matchStartLineIdx > 0 ? matchStartLineIdx - 1 : -1;
+    const afterLineIdx = matchEndLineIdx < contentLines.length - 1 ? matchEndLineIdx + 1 : -1;
+    // Compute diff between oldStr and newStr
+    const diffLines = computeDiff(oldStr, newStr);
+    const output = [];
+    // Context before
+    if (beforeLineIdx !== -1) {
+        const lineNum = beforeLineIdx + 1;
+        output.push(`  ${DIFF_DIM}  ${lineNum}  ${contentLines[beforeLineIdx]}${DIFF_RESET}`);
+    }
+    // Diff lines with line numbers
+    let oldLn = firstLineNum;
+    let newLn = firstLineNum;
+    for (const line of diffLines) {
+        if (line.type === 'delete') {
+            output.push(`  ${DIFF_RED}- ${oldLn}  ${line.content}${DIFF_RESET}`);
+            oldLn++;
+        }
+        else if (line.type === 'insert') {
+            output.push(`  ${DIFF_GREEN}+ ${newLn}  ${line.content}${DIFF_RESET}`);
+            newLn++;
+        }
+        else {
+            output.push(`  ${DIFF_DIM}  ${oldLn}  ${line.content}${DIFF_RESET}`);
+            oldLn++;
+            newLn++;
+        }
+    }
+    // Context after
+    if (afterLineIdx !== -1) {
+        const lineNum = afterLineIdx + 1;
+        output.push(`  ${DIFF_DIM}  ${lineNum}  ${contentLines[afterLineIdx]}${DIFF_RESET}`);
+    }
+    return output.join('\n');
 }
 /**
  * Normalize a line for whitespace-tolerant comparison:
@@ -27,7 +169,8 @@ function generateDiff(oldStr, newStr) {
  * - Extra internal spaces → `"foo  bar"` → `"foo bar"`
  * - Blank lines with spaces → `"   "` → `""`
  */
-function normalizeLine(s) {
+/** Export for testing */
+export function normalizeLine(s) {
     return s.trim().replace(/[ \t]{2,}/g, ' ');
 }
 /**
@@ -38,7 +181,8 @@ function normalizeLine(s) {
  * so the caller can do content.slice(match.index, match.index + match.length)
  * to extract the actual matched text (with its original whitespace).
  */
-function findAllLinesTolerant(content, oldString) {
+/** Export for testing */
+export function findAllLinesTolerant(content, oldString) {
     if (oldString === '')
         return [];
     const contentLines = content.split('\n');
@@ -75,134 +219,220 @@ function findAllLinesTolerant(content, oldString) {
     }
     return matches;
 }
+/** Export for testing */
+export function parseMarkdownEdit(content) {
+    const edits = [];
+    function parseEditBlock(raw) {
+        // Remove stray ``` lines (model may close the block early before new:)
+        const cleaned = raw.replace(/^```\s*$/gm, '');
+        const fileMatch = cleaned.match(/^file:\s*(.+)$/m);
+        if (!fileMatch)
+            return null;
+        const filePath = fileMatch[1].trim();
+        let oldString = '';
+        let newString = '';
+        const oldMatch = cleaned.match(/^old:(?:\s*\|\d*\s*\n)?([\s\S]*?)^new:/m);
+        const newMatch = cleaned.match(/^new:(?:\s*\|\d*\s*\n)?([\s\S]*)$/m);
+        if (oldMatch) {
+            oldString = oldMatch[1].replace(/^\n+/, '').replace(/\n+$/, '');
+        }
+        if (newMatch) {
+            newString = newMatch[1].replace(/^\n+/, '').replace(/\n+$/, '');
+        }
+        return { file_path: filePath, old_string: oldString || '', new_string: newString || '' };
+    }
+    // Strategy 1: Non-greedy block regex (handles multi-edit, correct formatting)
+    const blockRegex = /```edit\s*([\s\S]*?)```/gi;
+    for (const regexMatch of content.matchAll(blockRegex)) {
+        const edit = parseEditBlock(regexMatch[1]);
+        if (edit)
+            edits.push(edit);
+    }
+    // Strategy 2: If no edit with new_string found (model likely closed ``` before new:),
+    // retry with greedy matching to capture everything up to the last ```
+    if (!edits.some(e => e.new_string)) {
+        edits.length = 0;
+        const greedyRegex = /```edit\s*([\s\S]*)```/g;
+        for (const regexMatch of content.matchAll(greedyRegex)) {
+            const edit = parseEditBlock(regexMatch[1]);
+            if (edit)
+                edits.push(edit);
+        }
+    }
+    // Strategy 3: No block markers at all — try parsing raw content directly
+    if (edits.length === 0) {
+        const edit = parseEditBlock(content);
+        if (edit)
+            edits.push(edit);
+    }
+    return edits;
+}
+/** Extract edits from legacy JSON format (backward compatibility) */
+function extractEditsFromJSON(input) {
+    // Pattern 0: input is an array (edits passed directly instead of wrapped)
+    if (Array.isArray(input)) {
+        // Preserve array for validation
+        return input;
+    }
+    // Pattern 1: input has file_path, old_string, new_string at top level (missing edits array)
+    if (!Array.isArray(input.edits)) {
+        const keys = Object.keys(input);
+        // Check if the keys look like a single edit object (file_path + old_string + new_string)
+        const hasFilePath = typeof input.file_path === 'string';
+        const hasOldString = typeof input.old_string === 'string';
+        const hasNewString = typeof input.new_string === 'string';
+        if (hasFilePath && hasOldString && hasNewString) {
+            return [
+                {
+                    file_path: input.file_path,
+                    old_string: input.old_string,
+                    new_string: input.new_string,
+                },
+            ];
+        }
+        else if (hasFilePath && hasOldString) {
+            // Only file_path + old_string (missing new_string) — use a sentinel
+            // value so validation catches this as an error instead of silently deleting content.
+            return [
+                {
+                    file_path: input.file_path,
+                    old_string: input.old_string,
+                    new_string: input.new_string || '__MISSING_NEW_STRING__',
+                },
+            ];
+        }
+        else if (keys.length === 2 && hasFilePath && typeof input.new_string === 'string') {
+            // file_path + new_string but no old_string — treat as new file creation
+            return [
+                {
+                    file_path: input.file_path,
+                    old_string: '',
+                    new_string: input.new_string,
+                },
+            ];
+        }
+        else if (keys.length === 1 && hasFilePath) {
+            // Only file_path — maybe they meant create file with empty content?
+            return [{ file_path: input.file_path, old_string: '', new_string: '' }];
+        }
+        return [];
+    }
+    // If edits is an array (even empty), preserve for validation
+    if (Array.isArray(input.edits)) {
+        return input.edits;
+    }
+    return [];
+}
 export function createEditTool(applier, cwd) {
     return {
         definition: {
             name: 'edit',
-            description: `Replace exact text in files. Each edit object is a COMPLETE find-and-replace pair.
-Parameter: {"edits": [{"file_path": "...", "old_string": "...", "new_string": "..."}]}
+            description: `Replace exact text in files using markdown code block format.
 
 HOW TO USE:
 1. Read the file first with \`read\`
 2. Copy the EXACT text to replace — include 2-3 lines of context before/after
-3. Call: edit({ edits: [{ file_path, old_string, new_string }] })
+3. Use markdown code block format below
 
-CRITICAL RULES:
-- Each edit MUST have BOTH old_string AND new_string (a complete find-replace pair)
-- old_string must match EXACTLY (whitespace, indentation, line breaks)
-- old_string must be UNIQUE — include enough surrounding context
-- Do NOT include the "<lineNumber>: " prefix from read output
-- \`edits\` is always an array. Never pass file_path/old_string/new_string as top-level keys.
-- To batch multiple independent edits, add multiple objects to the array
+FORMAT:
+\`\`\`edit
+file: <file_path>
+old: |
+  <exact text to find>
+new: |
+  <replacement text>
+\`\`\`
 
 EXAMPLES:
-  Single edit: edit({ edits: [{ file_path: "src/config.ts", old_string: "mode: 'code'", new_string: "mode: 'plan'" }] })
+Single edit:
+\`\`\`edit
+file: src/config.ts
+old: |
+  mode: 'code'
+new: |
+  mode: 'plan'
+\`\`\`
 
-  Batch edits: edit({ edits: [
-    { file_path: "src/a.ts", old_string: "foo", new_string: "bar" },
-    { file_path: "src/b.ts", old_string: "x", new_string: "y" }
-  ] })
+Create new file:
+\`\`\`edit
+file: src/new.ts
+old: |
+new: |
+  const x = 1
+\`\`\`
 
-  Create file: edit({ edits: [{ file_path: "src/new.ts", old_string: "", new_string: "const x = 1" }] })`,
+CRITICAL RULES:
+- old and new are separated by "old:" and "new:" labels
+- Use | after label for multi-line content
+- old_string must match EXACTLY (whitespace, indentation, line breaks)
+- Do NOT include the "<lineNumber>: " prefix from read output`,
             parameters: {
-                edits: {
-                    type: 'array',
-                    description: 'REQUIRED. Array of complete find-replace pairs. Each edit MUST have BOTH old_string AND new_string. Example: [{ file_path: "src/file.ts", old_string: "old", new_string: "new" }]',
+                content: {
+                    type: 'string',
+                    description: 'Markdown code block with edit instructions. See description for format.',
                     required: true,
-                    items: {
-                        type: 'object',
-                        properties: {
-                            file_path: { type: 'string', description: 'Path to the file' },
-                            old_string: {
-                                type: 'string',
-                                description: 'Text to FIND in the file. REQUIRED. Pair with new_string to form a complete find-replace. Pass "" to create a new file.',
-                            },
-                            new_string: {
-                                type: 'string',
-                                description: 'Replacement text. REQUIRED. Pair with old_string to form a complete find-replace. Pass "" to delete content.',
-                            },
-                        },
-                    },
                 },
             },
         },
         async execute(input) {
-            // ── Auto-correction: detect common misuse patterns ────────────────
-            // ── Debug: log raw input for diagnosing failures ─────────────
-            const rawInput = JSON.parse(JSON.stringify(input));
-            // Pattern 0: input is an array (edits passed directly instead of wrapped)
-            if (Array.isArray(input)) {
-                input = { edits: input };
-            }
-            // Pattern 1: input has file_path, old_string, new_string at top level (missing edits array)
-            if (!Array.isArray(input.edits)) {
-                const keys = Object.keys(input);
-                // Check if the keys look like a single edit object (file_path + old_string + new_string)
-                const hasFilePath = typeof input.file_path === 'string';
-                const hasOldString = typeof input.old_string === 'string';
-                const hasNewString = typeof input.new_string === 'string';
-                if (hasFilePath && hasOldString && hasNewString) {
-                    // Auto-correct: wrap into edits array
-                    input = {
-                        edits: [
-                            {
-                                file_path: input.file_path,
-                                old_string: input.old_string,
-                                new_string: input.new_string,
-                            },
-                        ],
-                    };
+            // Debug: keep rawInput for error messages (capture early for all error paths)
+            const rawInput = input;
+            // ── Parse markdown format ─────────────────────────────────────────
+            let edits = [];
+            // If input has 'content' field (new markdown format)
+            if (typeof input.content === 'string') {
+                // Compat: handle double-JSON-wrapped content
+                let contentStr = input.content;
+                try {
+                    const parsed = JSON.parse(contentStr);
+                    if (typeof parsed === 'string') {
+                        contentStr = parsed;
+                    }
+                    else if (parsed && typeof parsed === 'object' && typeof parsed.content === 'string') {
+                        contentStr = parsed.content;
+                    }
                 }
-                else if (hasFilePath && hasOldString) {
-                    // Only file_path + old_string (missing new_string) — still try
-                    input = {
-                        edits: [
-                            {
-                                file_path: input.file_path,
-                                old_string: input.old_string,
-                                new_string: input.new_string || '',
-                            },
-                        ],
-                    };
+                catch {
+                    // Not JSON — use as-is
                 }
-                else if (keys.length === 1 && hasFilePath) {
-                    // Only file_path — maybe they meant create file with empty content?
-                    input = { edits: [{ file_path: input.file_path, old_string: '', new_string: '' }] };
+                edits = parseMarkdownEdit(contentStr);
+                if (edits.length === 0) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `Failed to parse edit format. Raw input: ${summarizeRawInput(rawInput)}\nUse: \`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\``,
+                    };
                 }
-                else if (keys.length === 2 && hasFilePath && typeof input.new_string === 'string') {
-                    // file_path + new_string but no old_string — treat as new file creation
-                    input = {
-                        edits: [{ file_path: input.file_path, old_string: '', new_string: input.new_string }],
+            }
+            else {
+                // Legacy JSON format (backward compatibility)
+                edits = extractEditsFromJSON(input);
+            }
+            if (edits.length === 0) {
+                // Check if input specifically had empty edits array (for better error message)
+                const inputEdits = input.edits;
+                if ('edits' in input && Array.isArray(inputEdits) && inputEdits.length === 0) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `edit FAILED — no edits to apply. The edits array exists but is empty. Raw input: ${summarizeRawInput(rawInput)}`,
                     };
                 }
-                else {
-                    // Can't auto-correct — give helpful error with examples
-                    const example = hasFilePath
-                        ? `edit({ edits: [{ file_path: "${input.file_path}", old_string: "...", new_string: "..." }] })`
-                        : `edit({ edits: [{ file_path: "src/file.ts", old_string: "old", new_string: "new" }] })`;
+                // Check if input has edits key but it's not an array
+                if ('edits' in input && !Array.isArray(input.edits)) {
                     return {
                         success: false,
                         output: '',
-                        error: `edit requires "edits" array. Received: ${JSON.stringify(rawInput)}. Usage: ${example}`,
+                        error: `edit requires "edits" array. Use markdown format: \`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\`\nRaw input: ${summarizeRawInput(rawInput)}`,
                     };
                 }
-            }
-            const edits = input.edits;
-            if (edits.length === 0) {
-                // Build a diagnostic: show what the AI received vs expected
-                const receivedKeys = Object.keys(rawInput);
-                const hint = receivedKeys.length === 1 && receivedKeys[0] === 'edits'
-                    ? 'The edits array exists but is empty — include at least one edit object with file_path, old_string, and new_string.'
-                    : receivedKeys.includes('file_path')
-                        ? 'Top-level file_path/old_string/new_string detected — wrap them in an edits array: { edits: [{ file_path, old_string, new_string }] }'
-                        : 'No usable edit data found in the input. Provide an edits array with at least one edit.';
                 return {
                     success: false,
                     output: '',
-                    error: `edit FAILED — no edits to apply. Raw input: ${JSON.stringify(rawInput)}. ${hint}`,
+                    error: `No valid edits found (empty or invalid format). The edit array must contain objects with file_path, old_string, and new_string. Use markdown code block format: \`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\`\nRaw input: ${summarizeRawInput(rawInput)}`,
                 };
             }
-            // Validate each edit object — catch missing old_string/new_string early
+            // Validate each edit object
             const editErrors = [];
             for (let i = 0; i < edits.length; i++) {
                 const e = edits[i];
@@ -213,16 +443,21 @@ EXAMPLES:
                     missing.push('old_string');
                 if (typeof e.new_string !== 'string')
                     missing.push('new_string');
+                if (e.new_string === '__MISSING_NEW_STRING__') {
+                    missing.push('new_string (required — LLM must provide a non-empty replacement)');
+                }
                 if (missing.length > 0) {
-                    editErrors.push(`  edit #${i + 1}: missing ${missing.join(', ')} (has: ${Object.keys(e).join(', ')})`);
+                    const present = Object.keys(e)
+                        .filter(k => typeof e[k] === 'string')
+                        .join(', ');
+                    editErrors.push(`  edit #${i + 1}: missing ${missing.join(', ')}${present ? ` (has: ${present})` : ''}`);
                 }
             }
             if (editErrors.length > 0) {
                 return {
                     success: false,
                     output: '',
-                    error: `edit FAILED — ${editErrors.length} of ${edits.length} edit(s) have missing fields.\n${editErrors.join('\n')}\n\nReceived: ${JSON.stringify(rawInput)}\n\nEach edit object must be a COMPLETE find-replace pair with BOTH old_string AND new_string.
-Do NOT split old_string (text to find) and new_string (replacement) across different edit objects.`,
+                    error: `edit FAILED — ${editErrors.length} of ${edits.length} edit(s) have missing fields.\n${editErrors.join('\n')}\n\nReceived: ${summarizeRawInput(rawInput)}\n\nEach edit object must be a COMPLETE find-replace pair with BOTH old_string AND new_string.`,
                 };
             }
             const fileGroups = new Map();
@@ -256,34 +491,24 @@ Do NOT split old_string (text to find) and new_string (replacement) across diffe
                     e.new_string = e.new_string.replace(/\r\n/g, '\n');
                     if (e.old_string === '') {
                         if (content !== null) {
-                            const diag = JSON.stringify({
-                                file_path: e.file_path,
-                                old_string: '',
-                                new_string: e.new_string,
-                            });
-                            const suggestion = `  → Use edit with old_string to replace existing content, or choose a different path.`;
-                            results.push(`  FAIL ${relPath}: File already exists — Raw input: ${JSON.stringify(rawInput)}
-  Edit: ${diag}
-${suggestion}`);
+                            // File already exists in-memory (from prior edit in this batch)
+                            // or on disk — treat as error to prevent silent overwrites.
+                            results.push(`  FAIL ${relPath}: Cannot create — file already exists (duplicate create in batch or file on disk)`);
                             if (!anyFailed) {
                                 anyFailed = true;
-                                firstError = `File already exists: ${relPath}`;
+                                firstError = `Cannot create file "${relPath}": file already exists`;
                             }
                             break;
                         }
                         const newLines = e.new_string.split('\n').length;
                         content = e.new_string;
-                        results.push(`  Created ${relPath} (${newLines} lines):\n${generateDiff('', e.new_string)}`);
+                        results.push(`  Created ${relPath} (${newLines} lines):\n${generateDiff('', e.new_string, 1)}`);
                         continue;
                     }
                     if (content === null) {
-                        const diag = JSON.stringify({
-                            file_path: e.file_path,
-                            old_string: e.old_string,
-                            new_string: e.new_string,
-                        });
+                        const diag = buildDiag(e);
                         const suggestion = `  → Check the file path, or create it first with old_string: "" (empty string).`;
-                        results.push(`  FAIL ${relPath}: File not found — Raw input: ${JSON.stringify(rawInput)}
+                        results.push(`  FAIL ${relPath}: File not found
   Edit: ${diag}
 ${suggestion}`);
                         if (!anyFailed) {
@@ -299,13 +524,9 @@ ${suggestion}`);
                         // Exact match found — check for duplicates
                         const lastIdx = content.lastIndexOf(e.old_string);
                         if (exactIdx !== lastIdx) {
-                            const diag = JSON.stringify({
-                                file_path: e.file_path,
-                                old_string: e.old_string,
-                                new_string: e.new_string,
-                            });
+                            const diag = buildDiag(e);
                             const suggestion = `  → Include more surrounding context lines (2-3 lines before and after) in old_string to make the match unique.`;
-                            results.push(`  FAIL ${relPath}: old_string appears MULTIPLE times — Raw input: ${JSON.stringify(rawInput)}
+                            results.push(`  FAIL ${relPath}: old_string appears MULTIPLE times
   Edit: ${diag}
 ${suggestion}`);
                             if (!anyFailed) {
@@ -340,15 +561,11 @@ ${suggestion}`);
                                 const lines = contentLines.slice(0, Math.min(contentLines.length, 5));
                                 hint = `\n  File content (first ${lines.length} lines):\n  """\n${lines.join('\n')}\n  """`;
                             }
-                            const diag = JSON.stringify({
-                                file_path: e.file_path,
-                                old_string: e.old_string,
-                                new_string: e.new_string,
-                            });
+                            const diag = buildDiag(e);
                             const readHint = readWarning ? `\n  ${readWarning}` : '';
                             const suggestion = `  → Read the file again with read({ paths: ["${e.file_path}"] }) to get current content, then retry with exact matching text. Include 2-3 lines of surrounding context for uniqueness.${readHint}`;
-                            results.push(`  FAIL ${relPath}: old_string not found — Raw input: ${JSON.stringify(rawInput)}
-  Edit: ${diag}${hint}
+                            results.push(`  FAIL ${relPath}: old_string not found${hint}
+  Edit: ${diag}
 ${suggestion}`);
                             if (!anyFailed) {
                                 anyFailed = true;
@@ -357,13 +574,9 @@ ${suggestion}`);
                             break;
                         }
                         if (tolerant.length > 1) {
-                            const diag = JSON.stringify({
-                                file_path: e.file_path,
-                                old_string: e.old_string,
-                                new_string: e.new_string,
-                            });
+                            const diag = buildDiag(e);
                             const suggestion = `  → Include more surrounding context lines (2-3 lines before and after) in old_string to make the match unique.`;
-                            results.push(`  FAIL ${relPath}: old_string appears MULTIPLE times (whitespace-normalized) — Raw input: ${JSON.stringify(rawInput)}\n  Edit: ${diag}\n${suggestion}`);
+                            results.push(`  FAIL ${relPath}: old_string appears MULTIPLE times (whitespace-normalized)\n  Edit: ${diag}\n${suggestion}`);
                             if (!anyFailed) {
                                 anyFailed = true;
                                 firstError = `old_string appears MULTIPLE times in ${relPath} (whitespace-normalized)`;
@@ -376,9 +589,13 @@ ${suggestion}`);
                             strategy: 'tolerant',
                         };
                     }
-                    const strategyLabel = matchInfo.strategy === 'tolerant' ? ' (whitespace-normalized)' : '';
-                    const diff = generateDiff(e.old_string, e.new_string);
-                    results.push(`  Edited ${relPath}${strategyLabel}:\n${diff}`);
+                    // For tolerant matching, use the actual file text at the match position
+                    // so the diff reflects what was really in the file (with original whitespace).
+                    const matchedOld = matchInfo.strategy === 'tolerant'
+                        ? content.slice(matchInfo.index, matchInfo.index + matchInfo.length)
+                        : e.old_string;
+                    const diff = generateDiffWithContext(content, matchedOld, e.new_string, matchInfo.index, matchInfo.length);
+                    results.push(`  Edited ${relPath}:\n${diff}`);
                     content =
                         content.slice(0, matchInfo.index) +
                             e.new_string +
@@ -415,7 +632,7 @@ ${suggestion}`);
                 return {
                     success: false,
                     output: '',
-                    error: `Edit FAILED — all changes rolled back. Raw input: ${JSON.stringify(rawInput)}\n${failLines}\n\n${firstError}`,
+                    error: `Edit FAILED — all changes rolled back.\n${failLines}\n\n${firstError}`,
                 };
             }
             for (const [resolved, content] of modifiedFiles) {
@@ -432,7 +649,7 @@ ${suggestion}`);
                     return {
                         success: false,
                         output: '',
-                        error: `Failed to write ${path.relative(cwd, resolved).replace(/\\/g, '/')}: ${fmtErr(err)}. Input: ${JSON.stringify(rawInput)}`,
+                        error: `Failed to write ${path.relative(cwd, resolved).replace(/\\/g, '/')}: ${fmtErr(err)}. Input: ${summarizeRawInput(rawInput)}`,
                     };
                 }
                 applier.markRead(resolved);