lonny-agent 0.2.4 → 0.2.6

package/src/tools/edit.ts

@@ -1,14 +1,14 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
+import { DIFF_DELETE, DIFF_INSERT, diffLinesRaw } from 'jest-diff'
 import type { FileReadTracker } from '../diff/apply.js'
 import { fmtErr } from './errors.js'
 import type { Tool, ToolResult } from './types.js'
 
 // ── Diff types ────────────────────────────────────────────────────────────
-export type DiffLineType = 'old' | 'new'
+export type DiffLineType = 'delete' | 'insert' | 'equal'
 
 export interface DiffLine {
-  lineNum: number
   type: DiffLineType
   content: string
 }
@@ -16,11 +16,13 @@ export interface DiffLine {
 // ── 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: SingleEdit): string {
@@ -31,35 +33,51 @@ function buildDiag(edit: SingleEdit): string {
   })
 }
 
-/** Compute diff lines (pure data, no rendering) */
-export function computeDiff(oldStr: string, newStr: string, startLine = 0): DiffLine[] {
-  const oldLines = oldStr === '' ? [] : oldStr.split('\n')
-  const newLines = newStr.split('\n')
-  const lines: DiffLine[] = []
-
-  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] })
-  }
+/** Summarize raw input for error messages to avoid dumping huge strings into the LLM context. */
+function summarizeRawInput(rawInput: unknown): string {
+  const s = JSON.stringify(rawInput)
+  if (s.length <= 500) return s
+  return `${s.slice(0, 500)}... [truncated, total ${s.length} chars]`
+}
 
-  return lines
+/** Compute diff lines using jest-diff for proper line-level diffs */
+export function computeDiff(oldStr: string, newStr: string): DiffLine[] {
+  const oldLines = oldStr === '' ? [] : oldStr.split('\n')
+  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' as const)
+        : d[0] === DIFF_INSERT
+          ? ('insert' as const)
+          : ('equal' as const),
+    content: d[1],
+  }))
 }
 
-/** Terminal renderer */
-export function renderDiffTerminal(lines: DiffLine[]): string {
+/** Terminal renderer — unified-diff format with color */
+export function renderDiffTerminal(lines: DiffLine[], startLineNum?: number): string {
   if (lines.length === 0) return ''
 
-  const maxLineNum = Math.max(...lines.map(l => l.lineNum))
-  const lineNumWidth = String(maxLineNum).length
-  const fmtLineNum = (n: number) => String(n).padStart(lineNumWidth, ' ')
-
   const output: string[] = []
+  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')
 }
@@ -68,37 +86,109 @@ export function renderDiffTerminal(lines: DiffLine[]): string {
 export function renderDiffHtml(lines: DiffLine[]): string {
   if (lines.length === 0) return ''
 
-  const maxLineNum = Math.max(...lines.map(l => l.lineNum))
-  const lineNumWidth = String(maxLineNum).length
-  const fmtLineNum = (n: number) => String(n).padStart(lineNumWidth, ' ')
-
   const output: string[] = []
   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: string): string {
+export function escapeHtml(str: string): string {
   return str
     .replace(/&/g, '&amp;')
     .replace(/</g, '&lt;')
     .replace(/>/g, '&gt;')
     .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: string, newStr: string, startLine = 0): string {
-  const lines = computeDiff(oldStr, newStr, startLine)
-  return renderDiffTerminal(lines)
+export function generateDiff(oldStr: string, newStr: string, startLineNum?: number): string {
+  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: string,
+  oldStr: string,
+  newStr: string,
+  matchIndex: number,
+  matchLength: number,
+): string {
+  // 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: string[] = []
+
+  // 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')
 }
 
 /**
@@ -111,7 +201,8 @@ export function generateDiff(oldStr: string, newStr: string, startLine = 0): str
  * - Extra internal spaces → `"foo  bar"` → `"foo bar"`
  * - Blank lines with spaces → `"   "` → `""`
  */
-function normalizeLine(s: string): string {
+/** Export for testing */
+export function normalizeLine(s: string): string {
   return s.trim().replace(/[ \t]{2,}/g, ' ')
 }
 
@@ -128,7 +219,8 @@ interface MatchPos {
  * 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: string, oldString: string): MatchPos[] {
+/** Export for testing */
+export function findAllLinesTolerant(content: string, oldString: string): MatchPos[] {
   if (oldString === '') return []
 
   const contentLines = content.split('\n')
@@ -175,147 +267,233 @@ interface SingleEdit {
   new_string: string
 }
 
+type Edit = SingleEdit
+
+/** Export for testing */
+export function parseMarkdownEdit(content: string): Edit[] {
+  const edits: Edit[] = []
+
+  function parseEditBlock(raw: string): Edit | null {
+    // 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: Record<string, unknown>): Edit[] {
+  // Pattern 0: input is an array (edits passed directly instead of wrapped)
+  if (Array.isArray(input)) {
+    // Preserve array for validation
+    return input as Edit[]
+  }
+
+  // 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 as string,
+          old_string: input.old_string as string,
+          new_string: input.new_string as 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 as string,
+          old_string: input.old_string as string,
+          new_string: (input.new_string as 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 as string,
+          old_string: '',
+          new_string: input.new_string as string,
+        },
+      ]
+    } else if (keys.length === 1 && hasFilePath) {
+      // Only file_path — maybe they meant create file with empty content?
+      return [{ file_path: input.file_path as string, old_string: '', new_string: '' }]
+    }
+    return []
+  }
+
+  // If edits is an array (even empty), preserve for validation
+  if (Array.isArray(input.edits)) {
+    return input.edits as Edit[]
+  }
+
+  return []
+}
+
 export function createEditTool(applier: FileReadTracker, cwd: string): Tool {
   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'" }] })
-
-  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" }
-  ] })
+Single edit:
+\`\`\`edit
+file: src/config.ts
+old: |
+  mode: 'code'
+new: |
+  mode: 'plan'
+\`\`\`
+
+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): Promise<ToolResult> {
-      // ── Auto-correction: detect common misuse patterns ────────────────
-      // ── Debug: log raw input for diagnosing failures ─────────────
-      let rawInput: unknown = input
-      try {
-        rawInput = structuredClone(input)
-      } catch {
-        console.error('[edit] Failed to clone input:', input)
-        rawInput = input
-      }
+      // Debug: keep rawInput for error messages (capture early for all error paths)
+      const rawInput = input
 
-      // Pattern 0: input is an array (edits passed directly instead of wrapped)
-      if (Array.isArray(input)) {
-        input = { edits: input }
-      }
+      // ── Parse markdown format ─────────────────────────────────────────
+      let edits: Edit[] = []
 
-      // 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,
-              },
-            ],
-          }
-        } 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 || '',
-              },
-            ],
-          }
-        } 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: '' }] }
-        } 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 }],
+      // 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 {
-          // 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" }] })`
+        } catch {
+          // Not JSON — use as-is
+        }
+        edits = parseMarkdownEdit(contentStr)
+        if (edits.length === 0) {
           return {
             success: false,
             output: '',
-            error: `edit requires "edits" array. Received: ${JSON.stringify(rawInput)}. Usage: ${example}`,
+            error: `Failed to parse edit format. Raw input: ${summarizeRawInput(rawInput)}\nUse: \`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\``,
           }
         }
+      } else {
+        // Legacy JSON format (backward compatibility)
+        edits = extractEditsFromJSON(input as Record<string, unknown>)
       }
 
-      const edits = input.edits as SingleEdit[]
       if (edits.length === 0) {
-        // Build a diagnostic: show what the AI received vs expected
-        const receivedKeys = Object.keys(rawInput as Record<string, unknown>)
-        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.'
+        // Check if input specifically had empty edits array (for better error message)
+        const inputEdits = (input as Record<string, unknown>).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)}`,
+          }
+        }
+        // Check if input has edits key but it's not an array
+        if ('edits' in input && !Array.isArray((input as Record<string, unknown>).edits)) {
+          return {
+            success: false,
+            output: '',
+            error: `edit requires "edits" array. Use markdown format: \`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\`\nRaw input: ${summarizeRawInput(rawInput)}`,
+          }
+        }
         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: string[] = []
       for (let i = 0; i < edits.length; i++) {
         const e = edits[i]
@@ -323,9 +501,15 @@ EXAMPLES:
         if (typeof e.file_path !== 'string' || !e.file_path) missing.push('file_path')
         if (typeof e.old_string !== 'string') 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) {
+          const present = Object.keys(e)
+            .filter(k => typeof e[k as keyof Edit] === 'string')
+            .join(', ')
           editErrors.push(
-            `  edit #${i + 1}: missing ${missing.join(', ')} (has: ${Object.keys(e).join(', ')})`,
+            `  edit #${i + 1}: missing ${missing.join(', ')}${present ? ` (has: ${present})` : ''}`,
           )
         }
       }
@@ -333,8 +517,7 @@ EXAMPLES:
         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.`,
         }
       }
 
@@ -374,21 +557,21 @@ Do NOT split old_string (text to find) and new_string (replacement) across diffe
 
           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)}`,
+              `  Created ${relPath} (${newLines} lines):\n${generateDiff('', e.new_string, 1)}`,
             )
             continue
           }
@@ -396,7 +579,7 @@ ${suggestion}`)
           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) {
@@ -418,7 +601,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) {
@@ -457,8 +640,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
@@ -470,7 +653,7 @@ ${suggestion}`)
               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}`,
+                `  FAIL ${relPath}: old_string appears MULTIPLE times (whitespace-normalized)\n  Edit: ${diag}\n${suggestion}`,
               )
               if (!anyFailed) {
                 anyFailed = true
@@ -485,10 +668,20 @@ ${suggestion}`)
             }
           }
 
-          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 +
@@ -523,7 +716,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}`,
         }
       }
 
@@ -539,7 +732,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)