lonny-agent 0.2.4 → 0.2.7

package/dist/tools/edit.js

@@ -1,13 +1,16 @@
 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 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';
-// ── ANSI colors for HTML output ───────────────────────────────────────────
+// ── 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({
@@ -16,31 +19,50 @@ function buildDiag(edit) {
         new_string: edit.new_string,
     });
 }
-/** Compute diff lines (pure data, no rendering) */
-export function computeDiff(oldStr, newStr, startLine = 0) {
+/** 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 (let i = 0; i < oldLines.length; i++) {
-        lines.push({ lineNum: startLine + i, type: 'old', content: oldLines[i] });
-    }
-    for (let i = 0; i < newLines.length; i++) {
-        lines.push({ lineNum: startLine + i, type: 'new', content: newLines[i] });
-    }
-    return lines;
+    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 */
-export function renderDiffTerminal(lines) {
+/** Terminal renderer — unified-diff format with color */
+export function renderDiffTerminal(lines, startLineNum) {
     if (lines.length === 0)
         return '';
-    const maxLineNum = Math.max(...lines.map(l => l.lineNum));
-    const lineNumWidth = String(maxLineNum).length;
-    const fmtLineNum = (n) => String(n).padStart(lineNumWidth, ' ');
     const output = [];
+    let oldLn = startLineNum ?? 1;
+    let newLn = startLineNum ?? 1;
     for (const line of lines) {
-        const color = line.type === 'old' ? DIFF_RED : DIFF_GREEN;
-        const reset = DIFF_RESET;
-        output.push(`  ${fmtLineNum(line.lineNum)} ${color}${line.content}${reset}`);
+        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++;
+        }
     }
     return output.join('\n');
 }
@@ -48,32 +70,94 @@ export function renderDiffTerminal(lines) {
 export function renderDiffHtml(lines) {
     if (lines.length === 0)
         return '';
-    const maxLineNum = Math.max(...lines.map(l => l.lineNum));
-    const lineNumWidth = String(maxLineNum).length;
-    const fmtLineNum = (n) => String(n).padStart(lineNumWidth, ' ');
     const output = [];
     for (const line of lines) {
-        const color = line.type === 'old' ? HTML_RED : HTML_GREEN;
-        const style = `color: ${color};`;
-        output.push(`  <span style="${style}">${fmtLineNum(line.lineNum)} ${escapeHtml(line.content)}</span>`);
+        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 output.join('\n');
 }
 /** Escape HTML special characters */
-function escapeHtml(str) {
+export function escapeHtml(str) {
     return str
         .replace(/&/g, '&amp;')
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
 }
 /**
- * Generate diff output (backward compatible).
- * Delegates to terminal renderer by default.
+ * Generate diff output using jest-diff.
+ * Returns terminal-colored unified-diff format with line numbers.
  */
-export function generateDiff(oldStr, newStr, startLine = 0) {
-    const lines = computeDiff(oldStr, newStr, startLine);
-    return renderDiffTerminal(lines);
+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:
@@ -85,7 +169,8 @@ export function generateDiff(oldStr, newStr, startLine = 0) {
  * - 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, ' ');
 }
 /**
@@ -96,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');
@@ -124,7 +210,12 @@ function findAllLinesTolerant(content, oldString) {
             // Compute matched text length in ORIGINAL content
             let matchedLen = 0;
             for (let j = 0; j < oldLines.length; j++) {
-                matchedLen += contentLines[start + j].length;
+                const line = contentLines[start + j];
+                let lineLen = line.length;
+                // CRLF: the last line's trailing \r is part of content but not in oldString
+                if (j === oldLines.length - 1 && line.endsWith('\r'))
+                    lineLen -= 1;
+                matchedLen += lineLen;
                 if (j < oldLines.length - 1)
                     matchedLen += 1; // +1 for the \n
             }
@@ -133,142 +224,222 @@ 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": "..."}]}
+            category: 'Edit',
+            group: 'File',
+            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',
-                    minItems: 1,
-                    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 ─────────────
-            let rawInput = input;
-            try {
-                rawInput = structuredClone(input);
-            }
-            catch {
-                console.error('[edit] Failed to clone input:', input);
-                rawInput = 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];
@@ -279,18 +450,81 @@ 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.`,
                 };
             }
+            // ── Path traversal security check (symlink-aware) ─────────────────
+            const resolvedCwd = path.resolve(cwd);
+            let realCwd;
+            try {
+                realCwd = fs.realpathSync(resolvedCwd);
+            }
+            catch {
+                realCwd = resolvedCwd;
+            }
+            for (let i = 0; i < edits.length; i++) {
+                const e = edits[i];
+                const resolved = path.resolve(cwd, e.file_path);
+                const relative = path.relative(resolvedCwd, resolved);
+                if (relative.startsWith('..') || path.isAbsolute(relative)) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: 'edit FAILED — Path traversal detected: "' +
+                            e.file_path +
+                            '" resolves outside the working directory "' +
+                            resolvedCwd +
+                            '". All file paths must be within the project directory.',
+                    };
+                }
+                // Symlink-aware check: resolve real path to detect traversal via symlink
+                let realPath;
+                try {
+                    realPath = fs.realpathSync(resolved);
+                }
+                catch {
+                    // File doesn't exist yet – resolve nearest existing ancestor through symlinks
+                    let dir = path.dirname(resolved);
+                    while (!fs.existsSync(dir)) {
+                        const parent = path.dirname(dir);
+                        if (parent === dir)
+                            break; // root
+                        dir = parent;
+                    }
+                    try {
+                        realPath = path.join(fs.realpathSync(dir), path.relative(dir, resolved));
+                    }
+                    catch {
+                        realPath = resolved;
+                    }
+                }
+                const realRelative = path.relative(realCwd, realPath);
+                if (realRelative.startsWith('..') || path.isAbsolute(realRelative)) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: 'edit FAILED — Path traversal detected via symlink: "' +
+                            e.file_path +
+                            '" resolves outside "' +
+                            realCwd +
+                            '".',
+                    };
+                }
+            }
             const fileGroups = new Map();
             for (const e of edits) {
                 const resolved = path.resolve(cwd, e.file_path);
@@ -322,26 +556,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 = buildDiag({ ...e, old_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 = 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) {
@@ -359,7 +591,7 @@ ${suggestion}`);
                         if (exactIdx !== lastIdx) {
                             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) {
@@ -397,8 +629,8 @@ ${suggestion}`);
                             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;
@@ -409,7 +641,7 @@ ${suggestion}`);
                         if (tolerant.length > 1) {
                             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)`;
@@ -422,10 +654,13 @@ ${suggestion}`);
                             strategy: 'tolerant',
                         };
                     }
-                    const strategyLabel = matchInfo.strategy === 'tolerant' ? ' (whitespace-normalized)' : '';
-                    const matchLineNum = content.substring(0, matchInfo.index).split('\n').length;
-                    const diff = generateDiff(e.old_string, e.new_string, matchLineNum - 1);
-                    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 +
@@ -462,7 +697,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) {
@@ -479,7 +714,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);