whale-code 6.5.5 → 6.5.7

package/dist/cli/services/tools/file-ops.js

@@ -3,6 +3,7 @@
  *
  * Extracted from local-tools.ts for single-responsibility.
  */
+
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { dirname, join } from "path";
 import { execSync } from "child_process";
@@ -11,333 +12,456 @@ import { backupFile } from "../file-history.js";
 import { notifyFileChanged } from "../lsp-manager.js";
 import { debugLog } from "../debug-log.js";
 export function resolvePath(p) {
-    if (p.startsWith("~/"))
-        return join(homedir(), p.slice(2));
-    return p;
+  if (p.startsWith("~/")) return join(homedir(), p.slice(2));
+  return p;
 }
+
+// ============================================================================
+// FILE READ CACHE — mtime-based, LRU eviction, session-scoped
+// ============================================================================
+
 const READ_CACHE_MAX = 100;
 const MAX_ENTRY_SIZE = 100_000; // 100KB — skip caching larger files
 const MAX_CACHE_BYTES = 10_000_000; // 10MB total budget
 let totalCacheBytes = 0;
 const readCache = new Map();
+
 /** Clear the session-level read cache. Call on session reset. */
 export function clearReadCache() {
-    readCache.clear();
-    totalCacheBytes = 0;
+  readCache.clear();
+  totalCacheBytes = 0;
 }
+
 /** Invalidate a specific path from the cache (call on write/edit). */
 function invalidateCache(path) {
-    const existing = readCache.get(path);
-    if (existing) {
-        totalCacheBytes -= existing.content.length;
-        readCache.delete(path);
-    }
+  const existing = readCache.get(path);
+  if (existing) {
+    totalCacheBytes -= existing.content.length;
+    readCache.delete(path);
+  }
 }
+
 /** LRU eviction: remove oldest entries when cache exceeds count or byte budget. */
 function evictIfNeeded() {
-    while (readCache.size >= READ_CACHE_MAX || totalCacheBytes > MAX_CACHE_BYTES) {
-        const oldest = readCache.keys().next().value;
-        if (!oldest)
-            break;
-        const entry = readCache.get(oldest);
-        if (entry)
-            totalCacheBytes -= entry.content.length;
-        readCache.delete(oldest);
-    }
+  while (readCache.size >= READ_CACHE_MAX || totalCacheBytes > MAX_CACHE_BYTES) {
+    const oldest = readCache.keys().next().value;
+    if (!oldest) break;
+    const entry = readCache.get(oldest);
+    if (entry) totalCacheBytes -= entry.content.length;
+    readCache.delete(oldest);
+  }
 }
+
 // ============================================================================
 // READ FILE
 // ============================================================================
+
 const IMAGE_EXTENSIONS = new Set(["png", "jpg", "jpeg", "gif", "webp"]);
 const IMAGE_MEDIA_TYPES = {
-    png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg",
-    gif: "image/gif", webp: "image/webp",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp"
 };
 const AUDIO_EXTENSIONS = new Set(["mp3", "wav", "aiff", "aac", "ogg", "flac", "m4a"]);
 const AUDIO_MEDIA_TYPES = {
-    mp3: "audio/mpeg", wav: "audio/wav", aiff: "audio/aiff",
-    aac: "audio/aac", ogg: "audio/ogg", flac: "audio/flac",
-    m4a: "audio/mp4",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  aiff: "audio/aiff",
+  aac: "audio/aac",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  m4a: "audio/mp4"
 };
 const AUDIO_MAX_SIZE = 25 * 1024 * 1024; // 25MB
+
 function formatTextFileResult(lines, input, content) {
-    const offset = input.offset || 1; // 1-based
-    const limit = input.limit;
-    if (offset > 1 || limit) {
-        const startIdx = Math.max(0, offset - 1);
-        const endIdx = limit ? startIdx + limit : lines.length;
-        const slice = lines.slice(startIdx, endIdx);
-        const numbered = slice.map((line, i) => {
-            const lineNum = startIdx + i + 1;
-            return `${String(lineNum).padStart(6)}  ${line}`;
-        });
-        let output = numbered.join("\n");
-        if (endIdx < lines.length) {
-            output += `\n\n... (showing lines ${startIdx + 1}-${Math.min(endIdx, lines.length)} of ${lines.length})`;
-        }
-        return { success: true, output };
-    }
-    if (content.length > 500_000) {
-        return { success: true, output: content.slice(0, 500_000) + `\n\n... (safety truncated, ${content.length.toLocaleString()} total chars)` };
+  const offset = input.offset || 1; // 1-based
+  const limit = input.limit;
+  if (offset > 1 || limit) {
+    const startIdx = Math.max(0, offset - 1);
+    const endIdx = limit ? startIdx + limit : lines.length;
+    const slice = lines.slice(startIdx, endIdx);
+    const numbered = slice.map((line, i) => {
+      const lineNum = startIdx + i + 1;
+      return `${String(lineNum).padStart(6)}  ${line}`;
+    });
+    let output = numbered.join("\n");
+    if (endIdx < lines.length) {
+      output += `\n\n... (showing lines ${startIdx + 1}-${Math.min(endIdx, lines.length)} of ${lines.length})`;
     }
-    return { success: true, output: content };
+    return {
+      success: true,
+      output
+    };
+  }
+  if (content.length > 500_000) {
+    return {
+      success: true,
+      output: content.slice(0, 500_000) + `\n\n... (safety truncated, ${content.length.toLocaleString()} total chars)`
+    };
+  }
+  return {
+    success: true,
+    output: content
+  };
 }
 export async function readFile(input) {
-    const path = resolvePath(input.path);
-    if (!existsSync(path))
-        return { success: false, output: `File not found: ${path}` };
-    const ext = path.split(".").pop()?.toLowerCase() || "";
-    // Image files -> base64 with marker for agent-loop to convert to image content block
-    if (IMAGE_EXTENSIONS.has(ext)) {
-        try {
-            const buffer = readFileSync(path);
-            const base64 = buffer.toString("base64");
-            const mediaType = IMAGE_MEDIA_TYPES[ext] || "image/png";
-            return { success: true, output: `__IMAGE__${mediaType}__${base64}` };
-        }
-        catch (err) {
-            return { success: false, output: `Failed to read image: ${err}` };
-        }
-    }
-    // Audio files -> base64 with marker for agent-loop to convert to audio content block
-    if (AUDIO_EXTENSIONS.has(ext)) {
-        try {
-            const stat = statSync(path);
-            if (stat.size > AUDIO_MAX_SIZE) {
-                return { success: false, output: `Audio file too large: ${(stat.size / 1024 / 1024).toFixed(1)}MB (max 25MB)` };
-            }
-            const buffer = readFileSync(path);
-            const base64 = buffer.toString("base64");
-            const mediaType = AUDIO_MEDIA_TYPES[ext] || "audio/mpeg";
-            return { success: true, output: `__AUDIO__${mediaType}__${base64}` };
-        }
-        catch (err) {
-            return { success: false, output: `Failed to read audio file: ${err}` };
-        }
+  const path = resolvePath(input.path);
+  if (!existsSync(path)) return {
+    success: false,
+    output: `File not found: ${path}`
+  };
+  const ext = path.split(".").pop()?.toLowerCase() || "";
+
+  // Image files -> base64 with marker for agent-loop to convert to image content block
+  if (IMAGE_EXTENSIONS.has(ext)) {
+    try {
+      const buffer = readFileSync(path);
+      const base64 = buffer.toString("base64");
+      const mediaType = IMAGE_MEDIA_TYPES[ext] || "image/png";
+      return {
+        success: true,
+        output: `__IMAGE__${mediaType}__${base64}`
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to read image: ${err}`
+      };
     }
-    // PDF files -> extract text
-    if (ext === "pdf") {
-        try {
-            const pdfParse = (await import("pdf-parse")).default;
-            const buffer = readFileSync(path);
-            const data = await pdfParse(buffer);
-            let text = data.text || "";
-            const totalPages = data.numpages || 0;
-            const pagesParam = input.pages;
-            // Apply page range filter if specified
-            if (pagesParam && text) {
-                const pageTexts = text.split(/\f/); // Form feed splits pages in most PDFs
-                const { start, end } = parsePageRange(pagesParam, pageTexts.length);
-                text = pageTexts.slice(start, end).join("\n\n---\n\n");
-            }
-            if (text.length > 500_000) {
-                text = text.slice(0, 500_000) + `\n\n... (safety truncated — ${text.length.toLocaleString()} chars total)`;
-            }
-            return {
-                success: true,
-                output: `PDF: ${path} (${totalPages} pages)\n\n${text}`,
-            };
-        }
-        catch (err) {
-            return { success: false, output: `Failed to parse PDF: ${err}` };
-        }
+  }
+
+  // Audio files -> base64 with marker for agent-loop to convert to audio content block
+  if (AUDIO_EXTENSIONS.has(ext)) {
+    try {
+      const stat = statSync(path);
+      if (stat.size > AUDIO_MAX_SIZE) {
+        return {
+          success: false,
+          output: `Audio file too large: ${(stat.size / 1024 / 1024).toFixed(1)}MB (max 25MB)`
+        };
+      }
+      const buffer = readFileSync(path);
+      const base64 = buffer.toString("base64");
+      const mediaType = AUDIO_MEDIA_TYPES[ext] || "audio/mpeg";
+      return {
+        success: true,
+        output: `__AUDIO__${mediaType}__${base64}`
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to read audio file: ${err}`
+      };
     }
-    // Text files — check cache first via mtime comparison
+  }
+
+  // PDF files -> extract text
+  if (ext === "pdf") {
     try {
-        const stat = statSync(path);
-        const cached = readCache.get(path);
-        if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-            // Cache hit — use previously read content
-            debugLog("file-ops", `readFile cache hit: ${path}`);
-            const content = cached.content;
-            const lines = content.split("\n");
-            // Move to end of map for LRU freshness
-            readCache.delete(path);
-            readCache.set(path, cached);
-            return formatTextFileResult(lines, input, content);
-        }
+      const pdfParse = (await import("pdf-parse")).default;
+      const buffer = readFileSync(path);
+      const data = await pdfParse(buffer);
+      let text = data.text || "";
+      const totalPages = data.numpages || 0;
+      const pagesParam = input.pages;
+
+      // Apply page range filter if specified
+      if (pagesParam && text) {
+        const pageTexts = text.split(/\f/); // Form feed splits pages in most PDFs
+        const {
+          start,
+          end
+        } = parsePageRange(pagesParam, pageTexts.length);
+        text = pageTexts.slice(start, end).join("\n\n---\n\n");
+      }
+      if (text.length > 500_000) {
+        text = text.slice(0, 500_000) + `\n\n... (safety truncated — ${text.length.toLocaleString()} chars total)`;
+      }
+      return {
+        success: true,
+        output: `PDF: ${path} (${totalPages} pages)\n\n${text}`
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to parse PDF: ${err}`
+      };
     }
-    catch {
-        // stat failed — fall through to normal read
+  }
+
+  // Text files — check cache first via mtime comparison
+  try {
+    const stat = statSync(path);
+    const cached = readCache.get(path);
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+      // Cache hit — use previously read content
+      debugLog("file-ops", `readFile cache hit: ${path}`);
+      const content = cached.content;
+      const lines = content.split("\n");
+      // Move to end of map for LRU freshness
+      readCache.delete(path);
+      readCache.set(path, cached);
+      return formatTextFileResult(lines, input, content);
     }
-    const content = readFileSync(path, "utf-8");
-    const lines = content.split("\n");
-    // Cache the read — skip caching files larger than MAX_ENTRY_SIZE
-    if (content.length <= MAX_ENTRY_SIZE) {
-        try {
-            const stat = statSync(path);
-            evictIfNeeded();
-            readCache.set(path, { content, mtimeMs: stat.mtimeMs, size: stat.size });
-            totalCacheBytes += content.length;
-        }
-        catch {
-            // stat failed — skip caching
-        }
+  } catch {
+    // stat failed — fall through to normal read
+  }
+  const content = readFileSync(path, "utf-8");
+  const lines = content.split("\n");
+
+  // Cache the read — skip caching files larger than MAX_ENTRY_SIZE
+  if (content.length <= MAX_ENTRY_SIZE) {
+    try {
+      const stat = statSync(path);
+      evictIfNeeded();
+      readCache.set(path, {
+        content,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size
+      });
+      totalCacheBytes += content.length;
+    } catch {
+      // stat failed — skip caching
     }
-    return formatTextFileResult(lines, input, content);
+  }
+  return formatTextFileResult(lines, input, content);
 }
 function parsePageRange(range, totalPages) {
-    const parts = range.split("-");
-    const start = Math.max(0, parseInt(parts[0], 10) - 1);
-    const end = parts.length > 1 ? Math.min(totalPages, parseInt(parts[1], 10)) : start + 1;
-    return { start, end };
+  const parts = range.split("-");
+  const start = Math.max(0, parseInt(parts[0], 10) - 1);
+  const end = parts.length > 1 ? Math.min(totalPages, parseInt(parts[1], 10)) : start + 1;
+  return {
+    start,
+    end
+  };
 }
+
 // ============================================================================
 // WRITE FILE
 // ============================================================================
+
 /** Compute a unified diff between old and new file lines using prefix/suffix matching */
 function computeWriteDiff(oldLines, newLines) {
-    const CTX = 3;
-    const MAX_PER_SIDE = 60;
-    // Find common prefix
-    let prefixLen = 0;
-    while (prefixLen < oldLines.length && prefixLen < newLines.length &&
-        oldLines[prefixLen] === newLines[prefixLen]) {
-        prefixLen++;
-    }
-    // Find common suffix (not overlapping prefix)
-    let suffixLen = 0;
-    while (suffixLen < (oldLines.length - prefixLen) &&
-        suffixLen < (newLines.length - prefixLen) &&
-        oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]) {
-        suffixLen++;
-    }
-    // If identical
-    if (prefixLen + suffixLen >= oldLines.length && prefixLen + suffixLen >= newLines.length) {
-        return []; // no changes
-    }
-    const oldMiddle = oldLines.slice(prefixLen, oldLines.length - suffixLen);
-    const newMiddle = newLines.slice(prefixLen, newLines.length - suffixLen);
-    // If most of the file changed, show a compact summary
-    if (oldMiddle.length > MAX_PER_SIDE * 2 && newMiddle.length > MAX_PER_SIDE * 2) {
-        const showOld = oldMiddle.slice(0, MAX_PER_SIDE);
-        const showNew = newMiddle.slice(0, MAX_PER_SIDE);
-        const ctxStart = Math.max(0, prefixLen - CTX);
-        const ctxBefore = oldLines.slice(ctxStart, prefixLen);
-        const parts = [`@@ -${ctxStart + 1},${ctxBefore.length + showOld.length} +${ctxStart + 1},${ctxBefore.length + showNew.length} @@`];
-        for (const l of ctxBefore)
-            parts.push(` ${l}`);
-        for (const l of showOld)
-            parts.push(`-${l}`);
-        parts.push(`-... (${oldMiddle.length - MAX_PER_SIDE} more lines removed)`);
-        for (const l of showNew)
-            parts.push(`+${l}`);
-        parts.push(`+... (${newMiddle.length - MAX_PER_SIDE} more lines added)`);
-        return parts;
-    }
-    // Build single hunk with context
+  const CTX = 3;
+  const MAX_PER_SIDE = 60;
+
+  // Find common prefix
+  let prefixLen = 0;
+  while (prefixLen < oldLines.length && prefixLen < newLines.length && oldLines[prefixLen] === newLines[prefixLen]) {
+    prefixLen++;
+  }
+
+  // Find common suffix (not overlapping prefix)
+  let suffixLen = 0;
+  while (suffixLen < oldLines.length - prefixLen && suffixLen < newLines.length - prefixLen && oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]) {
+    suffixLen++;
+  }
+
+  // If identical
+  if (prefixLen + suffixLen >= oldLines.length && prefixLen + suffixLen >= newLines.length) {
+    return []; // no changes
+  }
+  const oldMiddle = oldLines.slice(prefixLen, oldLines.length - suffixLen);
+  const newMiddle = newLines.slice(prefixLen, newLines.length - suffixLen);
+
+  // If most of the file changed, show a compact summary
+  if (oldMiddle.length > MAX_PER_SIDE * 2 && newMiddle.length > MAX_PER_SIDE * 2) {
+    const showOld = oldMiddle.slice(0, MAX_PER_SIDE);
+    const showNew = newMiddle.slice(0, MAX_PER_SIDE);
     const ctxStart = Math.max(0, prefixLen - CTX);
     const ctxBefore = oldLines.slice(ctxStart, prefixLen);
-    const newSuffixStart = newLines.length - suffixLen;
-    const ctxAfter = newLines.slice(newSuffixStart, Math.min(newSuffixStart + CTX, newLines.length));
-    const hunkOldLen = ctxBefore.length + oldMiddle.length + ctxAfter.length;
-    const hunkNewLen = ctxBefore.length + newMiddle.length + ctxAfter.length;
-    const parts = [`@@ -${ctxStart + 1},${hunkOldLen} +${ctxStart + 1},${hunkNewLen} @@`];
-    for (const l of ctxBefore)
-        parts.push(` ${l}`);
-    for (const l of oldMiddle.slice(0, MAX_PER_SIDE))
-        parts.push(`-${l}`);
-    if (oldMiddle.length > MAX_PER_SIDE)
-        parts.push(`-... (${oldMiddle.length - MAX_PER_SIDE} more lines removed)`);
-    for (const l of newMiddle.slice(0, MAX_PER_SIDE))
-        parts.push(`+${l}`);
-    if (newMiddle.length > MAX_PER_SIDE)
-        parts.push(`+... (${newMiddle.length - MAX_PER_SIDE} more lines added)`);
-    for (const l of ctxAfter)
-        parts.push(` ${l}`);
+    const parts = [`@@ -${ctxStart + 1},${ctxBefore.length + showOld.length} +${ctxStart + 1},${ctxBefore.length + showNew.length} @@`];
+    for (const l of ctxBefore) parts.push(` ${l}`);
+    for (const l of showOld) parts.push(`-${l}`);
+    parts.push(`-... (${oldMiddle.length - MAX_PER_SIDE} more lines removed)`);
+    for (const l of showNew) parts.push(`+${l}`);
+    parts.push(`+... (${newMiddle.length - MAX_PER_SIDE} more lines added)`);
     return parts;
+  }
+
+  // Build single hunk with context
+  const ctxStart = Math.max(0, prefixLen - CTX);
+  const ctxBefore = oldLines.slice(ctxStart, prefixLen);
+  const newSuffixStart = newLines.length - suffixLen;
+  const ctxAfter = newLines.slice(newSuffixStart, Math.min(newSuffixStart + CTX, newLines.length));
+  const hunkOldLen = ctxBefore.length + oldMiddle.length + ctxAfter.length;
+  const hunkNewLen = ctxBefore.length + newMiddle.length + ctxAfter.length;
+  const parts = [`@@ -${ctxStart + 1},${hunkOldLen} +${ctxStart + 1},${hunkNewLen} @@`];
+  for (const l of ctxBefore) parts.push(` ${l}`);
+  for (const l of oldMiddle.slice(0, MAX_PER_SIDE)) parts.push(`-${l}`);
+  if (oldMiddle.length > MAX_PER_SIDE) parts.push(`-... (${oldMiddle.length - MAX_PER_SIDE} more lines removed)`);
+  for (const l of newMiddle.slice(0, MAX_PER_SIDE)) parts.push(`+${l}`);
+  if (newMiddle.length > MAX_PER_SIDE) parts.push(`+... (${newMiddle.length - MAX_PER_SIDE} more lines added)`);
+  for (const l of ctxAfter) parts.push(` ${l}`);
+  return parts;
 }
 export function writeFile(input) {
-    const path = resolvePath(input.path);
-    const content = input.content;
-    invalidateCache(path); // Invalidate read cache before write
-    const existed = existsSync(path);
-    const oldContent = existed ? readFileSync(path, "utf-8") : null;
-    backupFile(path); // Save backup before modification
-    const dir = dirname(path);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    writeFileSync(path, content, "utf-8");
-    debugLog("tools", `write_file: ${path} (${content.length} chars)`);
-    notifyFileChanged(path);
-    const newLines = content.split("\n");
-    if (!existed || !oldContent) {
-        // New file — show as all-added unified diff
-        const previewMax = 30;
-        const preview = newLines.slice(0, previewMax).map(l => `+${l}`);
-        if (newLines.length > previewMax)
-            preview.push(`+... (+${newLines.length - previewMax} more lines)`);
-        return {
-            success: true,
-            output: `Created: ${path} (${newLines.length} lines, ${content.length} chars)\n@@ -0,0 +1,${Math.min(newLines.length, previewMax)} @@\n${preview.join("\n")}`,
-        };
-    }
-    // Overwrite — compute diff between old and new content
-    const oldLines = oldContent.split("\n");
-    const diff = computeWriteDiff(oldLines, newLines);
-    // Count changes
-    let added = 0, removed = 0;
-    for (const line of diff) {
-        if (line.startsWith("+"))
-            added++;
-        else if (line.startsWith("-"))
-            removed++;
-    }
-    const summary = `Added ${added} lines, removed ${removed} lines`;
+  const path = resolvePath(input.path);
+  const content = input.content;
+  invalidateCache(path); // Invalidate read cache before write
+  const existed = existsSync(path);
+  const oldContent = existed ? readFileSync(path, "utf-8") : null;
+  backupFile(path); // Save backup before modification
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, {
+    recursive: true
+  });
+  writeFileSync(path, content, "utf-8");
+  debugLog("tools", `write_file: ${path} (${content.length} chars)`);
+  notifyFileChanged(path);
+  const newLines = content.split("\n");
+  if (!existed || !oldContent) {
+    // New file — show as all-added unified diff
+    const previewMax = 30;
+    const preview = newLines.slice(0, previewMax).map(l => `+${l}`);
+    if (newLines.length > previewMax) preview.push(`+... (+${newLines.length - previewMax} more lines)`);
     return {
-        success: true,
-        output: `Updated: ${path} (${summary})\n${diff.join("\n")}`,
+      success: true,
+      output: `Created: ${path} (${newLines.length} lines, ${content.length} chars)\n@@ -0,0 +1,${Math.min(newLines.length, previewMax)} @@\n${preview.join("\n")}`
     };
+  }
+
+  // Overwrite — compute diff between old and new content
+  const oldLines = oldContent.split("\n");
+  const diff = computeWriteDiff(oldLines, newLines);
+
+  // Count changes
+  let added = 0,
+    removed = 0;
+  for (const line of diff) {
+    if (line.startsWith("+")) added++;else if (line.startsWith("-")) removed++;
+  }
+  const summary = `Added ${added} lines, removed ${removed} lines`;
+  return {
+    success: true,
+    output: `Updated: ${path} (${summary})\n${diff.join("\n")}`
+  };
 }
+
 // ============================================================================
 // EDIT FILE
 // ============================================================================
+
 export function editFile(input) {
-    const path = resolvePath(input.path);
-    const oldString = input.old_string;
-    const newString = input.new_string;
-    const replaceAll = input.replace_all ?? false;
-    if (!existsSync(path))
-        return { success: false, output: `File not found: ${path}` };
-    invalidateCache(path); // Invalidate read cache before edit
-    backupFile(path); // Save backup before modification
-    let content = readFileSync(path, "utf-8");
-    if (!content.includes(oldString))
-        return { success: false, output: "old_string not found in file" };
-    if (replaceAll) {
-        let count = 0;
-        if (newString.includes(oldString)) {
-            // Avoid infinite loop: use split-join for safe replacement
-            const parts = content.split(oldString);
-            count = parts.length - 1;
-            content = parts.join(newString);
-        }
-        else {
-            while (content.includes(oldString)) {
-                content = content.replace(oldString, newString);
-                count++;
-                if (count > 10000)
-                    break; // safety
-            }
-        }
-        writeFileSync(path, content, "utf-8");
-        notifyFileChanged(path);
-        return { success: true, output: `File edited: ${path} (${count} replacements)` };
+  const path = resolvePath(input.path);
+  const oldString = input.old_string;
+  const newString = input.new_string;
+  const replaceAll = input.replace_all ?? false;
+  if (!existsSync(path)) return {
+    success: false,
+    output: `File not found: ${path}`
+  };
+  invalidateCache(path); // Invalidate read cache before edit
+  backupFile(path); // Save backup before modification
+  let content = readFileSync(path, "utf-8");
+  if (!content.includes(oldString)) return {
+    success: false,
+    output: "old_string not found in file"
+  };
+  if (replaceAll) {
+    let count = 0;
+    if (newString.includes(oldString)) {
+      // Avoid infinite loop: use split-join for safe replacement
+      const parts = content.split(oldString);
+      count = parts.length - 1;
+      content = parts.join(newString);
+    } else {
+      while (content.includes(oldString)) {
+        content = content.replace(oldString, newString);
+        count++;
+        if (count > 10000) break; // safety
+      }
     }
-    // Single replacement (original behavior)
-    const idx = content.indexOf(oldString);
-    const newContent = content.slice(0, idx) + newString + content.slice(idx + oldString.length);
-    writeFileSync(path, newContent, "utf-8");
+    writeFileSync(path, content, "utf-8");
     notifyFileChanged(path);
-    // Generate unified diff with context and line numbers
+    return {
+      success: true,
+      output: `File edited: ${path} (${count} replacements)`
+    };
+  }
+
+  // Single replacement (original behavior)
+  const idx = content.indexOf(oldString);
+  const newContent = content.slice(0, idx) + newString + content.slice(idx + oldString.length);
+  writeFileSync(path, newContent, "utf-8");
+  notifyFileChanged(path);
+
+  // Generate unified diff with context and line numbers
+  const allOldLines = content.split("\n");
+  const allNewLines = newContent.split("\n");
+  const beforeEdit = content.slice(0, idx);
+  const startLine = beforeEdit.split("\n").length; // 1-based
+  const oldLines = oldString.split("\n");
+  const newLines = newString.split("\n");
+  const CTX = 3;
+  const MAX_LINES = 20;
+  const ctxStart = Math.max(1, startLine - CTX);
+  const ctxBeforeLines = allOldLines.slice(ctxStart - 1, startLine - 1);
+  const newEndLine = startLine + newLines.length - 1;
+  const ctxAfterLines = allNewLines.slice(newEndLine, Math.min(newEndLine + CTX, allNewLines.length));
+  const showOld = oldLines.slice(0, MAX_LINES);
+  const showNew = newLines.slice(0, MAX_LINES);
+  const hunkOldLen = ctxBeforeLines.length + showOld.length + ctxAfterLines.length;
+  const hunkNewLen = ctxBeforeLines.length + showNew.length + ctxAfterLines.length;
+  const diffParts = [];
+  diffParts.push(`@@ -${ctxStart},${hunkOldLen} +${ctxStart},${hunkNewLen} @@`);
+  for (const l of ctxBeforeLines) diffParts.push(` ${l}`);
+  for (const l of showOld) diffParts.push(`-${l}`);
+  if (oldLines.length > MAX_LINES) diffParts.push(`-... (${oldLines.length - MAX_LINES} more lines)`);
+  for (const l of showNew) diffParts.push(`+${l}`);
+  if (newLines.length > MAX_LINES) diffParts.push(`+... (${newLines.length - MAX_LINES} more lines)`);
+  for (const l of ctxAfterLines) diffParts.push(` ${l}`);
+  return {
+    success: true,
+    output: `File edited: ${path}\n${diffParts.join("\n")}`
+  };
+}
+
+// ============================================================================
+// MULTI EDIT
+// ============================================================================
+
+export function multiEdit(input) {
+  const path = resolvePath(input.file_path);
+  const edits = input.edits;
+  if (!existsSync(path)) return {
+    success: false,
+    output: `File not found: ${path}`
+  };
+  if (!Array.isArray(edits) || edits.length === 0) return {
+    success: false,
+    output: "edits array is required and must not be empty"
+  };
+  invalidateCache(path); // Invalidate read cache before edit
+  backupFile(path); // Save backup before modification
+  let content = readFileSync(path, "utf-8");
+  const diffParts = [];
+  const CTX = 2;
+  const MAX_LINES = 10;
+  for (let i = 0; i < edits.length; i++) {
+    const {
+      old_string,
+      new_string
+    } = edits[i];
+    const idx = content.indexOf(old_string);
+    if (idx === -1) {
+      return {
+        success: false,
+        output: `Edit ${i + 1}/${edits.length} failed: old_string not found (${i} edits applied successfully before failure)`
+      };
+    }
+
+    // Compute line numbers before applying edit
     const allOldLines = content.split("\n");
-    const allNewLines = newContent.split("\n");
     const beforeEdit = content.slice(0, idx);
-    const startLine = beforeEdit.split("\n").length; // 1-based
-    const oldLines = oldString.split("\n");
-    const newLines = newString.split("\n");
-    const CTX = 3;
-    const MAX_LINES = 20;
+    const startLine = beforeEdit.split("\n").length;
+    const oldLines = old_string.split("\n");
+    const newLines = new_string.split("\n");
+    const newContent = content.slice(0, idx) + new_string + content.slice(idx + old_string.length);
+    const allNewLines = newContent.split("\n");
     const ctxStart = Math.max(1, startLine - CTX);
     const ctxBeforeLines = allOldLines.slice(ctxStart - 1, startLine - 1);
     const newEndLine = startLine + newLines.length - 1;
@@ -346,208 +470,364 @@ export function editFile(input) {
     const showNew = newLines.slice(0, MAX_LINES);
     const hunkOldLen = ctxBeforeLines.length + showOld.length + ctxAfterLines.length;
     const hunkNewLen = ctxBeforeLines.length + showNew.length + ctxAfterLines.length;
-    const diffParts = [];
     diffParts.push(`@@ -${ctxStart},${hunkOldLen} +${ctxStart},${hunkNewLen} @@`);
-    for (const l of ctxBeforeLines)
-        diffParts.push(` ${l}`);
-    for (const l of showOld)
-        diffParts.push(`-${l}`);
-    if (oldLines.length > MAX_LINES)
-        diffParts.push(`-... (${oldLines.length - MAX_LINES} more lines)`);
-    for (const l of showNew)
-        diffParts.push(`+${l}`);
-    if (newLines.length > MAX_LINES)
-        diffParts.push(`+... (${newLines.length - MAX_LINES} more lines)`);
-    for (const l of ctxAfterLines)
-        diffParts.push(` ${l}`);
-    return { success: true, output: `File edited: ${path}\n${diffParts.join("\n")}` };
-}
-// ============================================================================
-// MULTI EDIT
-// ============================================================================
-export function multiEdit(input) {
-    const path = resolvePath(input.file_path);
-    const edits = input.edits;
-    if (!existsSync(path))
-        return { success: false, output: `File not found: ${path}` };
-    if (!Array.isArray(edits) || edits.length === 0)
-        return { success: false, output: "edits array is required and must not be empty" };
-    invalidateCache(path); // Invalidate read cache before edit
-    backupFile(path); // Save backup before modification
-    let content = readFileSync(path, "utf-8");
-    const diffParts = [];
-    const CTX = 2;
-    const MAX_LINES = 10;
-    for (let i = 0; i < edits.length; i++) {
-        const { old_string, new_string } = edits[i];
-        const idx = content.indexOf(old_string);
-        if (idx === -1) {
-            return {
-                success: false,
-                output: `Edit ${i + 1}/${edits.length} failed: old_string not found (${i} edits applied successfully before failure)`,
-            };
-        }
-        // Compute line numbers before applying edit
-        const allOldLines = content.split("\n");
-        const beforeEdit = content.slice(0, idx);
-        const startLine = beforeEdit.split("\n").length;
-        const oldLines = old_string.split("\n");
-        const newLines = new_string.split("\n");
-        const newContent = content.slice(0, idx) + new_string + content.slice(idx + old_string.length);
-        const allNewLines = newContent.split("\n");
-        const ctxStart = Math.max(1, startLine - CTX);
-        const ctxBeforeLines = allOldLines.slice(ctxStart - 1, startLine - 1);
-        const newEndLine = startLine + newLines.length - 1;
-        const ctxAfterLines = allNewLines.slice(newEndLine, Math.min(newEndLine + CTX, allNewLines.length));
-        const showOld = oldLines.slice(0, MAX_LINES);
-        const showNew = newLines.slice(0, MAX_LINES);
-        const hunkOldLen = ctxBeforeLines.length + showOld.length + ctxAfterLines.length;
-        const hunkNewLen = ctxBeforeLines.length + showNew.length + ctxAfterLines.length;
-        diffParts.push(`@@ -${ctxStart},${hunkOldLen} +${ctxStart},${hunkNewLen} @@`);
-        for (const l of ctxBeforeLines)
-            diffParts.push(` ${l}`);
-        for (const l of showOld)
-            diffParts.push(`-${l}`);
-        if (oldLines.length > MAX_LINES)
-            diffParts.push(`-... (${oldLines.length - MAX_LINES} more)`);
-        for (const l of showNew)
-            diffParts.push(`+${l}`);
-        if (newLines.length > MAX_LINES)
-            diffParts.push(`+... (${newLines.length - MAX_LINES} more)`);
-        for (const l of ctxAfterLines)
-            diffParts.push(` ${l}`);
-        content = newContent;
-    }
-    writeFileSync(path, content, "utf-8");
-    notifyFileChanged(path);
-    return {
-        success: true,
-        output: `Applied ${edits.length} edits to ${path}\n${diffParts.join("\n")}`,
-    };
+    for (const l of ctxBeforeLines) diffParts.push(` ${l}`);
+    for (const l of showOld) diffParts.push(`-${l}`);
+    if (oldLines.length > MAX_LINES) diffParts.push(`-... (${oldLines.length - MAX_LINES} more)`);
+    for (const l of showNew) diffParts.push(`+${l}`);
+    if (newLines.length > MAX_LINES) diffParts.push(`+... (${newLines.length - MAX_LINES} more)`);
+    for (const l of ctxAfterLines) diffParts.push(` ${l}`);
+    content = newContent;
+  }
+  writeFileSync(path, content, "utf-8");
+  notifyFileChanged(path);
+  return {
+    success: true,
+    output: `Applied ${edits.length} edits to ${path}\n${diffParts.join("\n")}`
+  };
 }
+
 // ============================================================================
 // NOTEBOOK EDIT
 // ============================================================================
+
 export function notebookEdit(input) {
-    const path = resolvePath(input.notebook_path);
-    const newSource = input.new_source || "";
-    const cellType = input.cell_type || "code";
-    const editMode = input.edit_mode || "replace";
-    const cellId = input.cell_id;
-    if (!existsSync(path))
-        return { success: false, output: `Notebook not found: ${path}` };
-    invalidateCache(path); // Invalidate read cache before notebook edit
-    let notebook;
-    try {
-        notebook = JSON.parse(readFileSync(path, "utf-8"));
-    }
-    catch (err) {
-        return { success: false, output: `Failed to parse notebook: ${err}` };
-    }
-    const cells = notebook.cells || [];
-    // Find cell by ID or numeric index
-    let cellIndex = -1;
-    if (cellId !== undefined) {
-        cellIndex = cells.findIndex((c) => c.id === cellId);
-        if (cellIndex === -1) {
-            const idx = parseInt(cellId, 10);
-            if (!isNaN(idx) && idx >= 0 && idx < cells.length)
-                cellIndex = idx;
-        }
+  const path = resolvePath(input.notebook_path);
+  const newSource = input.new_source || "";
+  const cellType = input.cell_type || "code";
+  const editMode = input.edit_mode || "replace";
+  const cellId = input.cell_id;
+  if (!existsSync(path)) return {
+    success: false,
+    output: `Notebook not found: ${path}`
+  };
+  invalidateCache(path); // Invalidate read cache before notebook edit
+
+  let notebook;
+  try {
+    notebook = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    return {
+      success: false,
+      output: `Failed to parse notebook: ${err}`
+    };
+  }
+  const cells = notebook.cells || [];
+
+  // Find cell by ID or numeric index
+  let cellIndex = -1;
+  if (cellId !== undefined) {
+    cellIndex = cells.findIndex(c => c.id === cellId);
+    if (cellIndex === -1) {
+      const idx = parseInt(cellId, 10);
+      if (!isNaN(idx) && idx >= 0 && idx < cells.length) cellIndex = idx;
     }
-    // Split source into notebook-format lines (each line ends with \n except last)
-    const sourceLines = newSource.split("\n").map((line, i, arr) => i < arr.length - 1 ? line + "\n" : line);
-    switch (editMode) {
-        case "replace": {
-            if (cellIndex < 0)
-                return { success: false, output: `Cell not found: ${cellId}` };
-            cells[cellIndex].source = sourceLines;
-            if (cellType)
-                cells[cellIndex].cell_type = cellType;
-            break;
-        }
-        case "insert": {
-            const newCell = {
-                cell_type: cellType,
-                source: sourceLines,
-                metadata: {},
-            };
-            if (cellType === "code") {
-                newCell.execution_count = null;
-                newCell.outputs = [];
-            }
-            if (cellIndex >= 0) {
-                cells.splice(cellIndex + 1, 0, newCell);
-            }
-            else {
-                cells.push(newCell);
-            }
-            break;
+  }
+
+  // Split source into notebook-format lines (each line ends with \n except last)
+  const sourceLines = newSource.split("\n").map((line, i, arr) => i < arr.length - 1 ? line + "\n" : line);
+  switch (editMode) {
+    case "replace":
+      {
+        if (cellIndex < 0) return {
+          success: false,
+          output: `Cell not found: ${cellId}`
+        };
+        cells[cellIndex].source = sourceLines;
+        if (cellType) cells[cellIndex].cell_type = cellType;
+        break;
+      }
+    case "insert":
+      {
+        const newCell = {
+          cell_type: cellType,
+          source: sourceLines,
+          metadata: {}
+        };
+        if (cellType === "code") {
+          newCell.execution_count = null;
+          newCell.outputs = [];
         }
-        case "delete": {
-            if (cellIndex < 0)
-                return { success: false, output: `Cell not found: ${cellId}` };
-            cells.splice(cellIndex, 1);
-            break;
+        if (cellIndex >= 0) {
+          cells.splice(cellIndex + 1, 0, newCell);
+        } else {
+          cells.push(newCell);
         }
-        default:
-            return { success: false, output: `Unknown edit_mode: ${editMode}` };
-    }
-    notebook.cells = cells;
-    writeFileSync(path, JSON.stringify(notebook, null, 1), "utf-8");
-    return { success: true, output: `Notebook ${editMode}d cell in ${path} (${cells.length} cells total)` };
+        break;
+      }
+    case "delete":
+      {
+        if (cellIndex < 0) return {
+          success: false,
+          output: `Cell not found: ${cellId}`
+        };
+        cells.splice(cellIndex, 1);
+        break;
+      }
+    default:
+      return {
+        success: false,
+        output: `Unknown edit_mode: ${editMode}`
+      };
+  }
+  notebook.cells = cells;
+  writeFileSync(path, JSON.stringify(notebook, null, 1), "utf-8");
+  return {
+    success: true,
+    output: `Notebook ${editMode}d cell in ${path} (${cells.length} cells total)`
+  };
 }
+
 // ============================================================================
 // LIST DIRECTORY
 // ============================================================================
+
 export function listDirectory(input) {
-    const path = resolvePath(input.path);
-    const recursive = input.recursive ?? false;
-    if (!existsSync(path))
-        return { success: false, output: `Directory not found: ${path}` };
-    if (recursive) {
-        try {
-            const escapedPath = path.replace(/'/g, "'\\''");
-            const output = execSync(`find '${escapedPath}' -maxdepth 4 -not -path '*/.*' 2>/dev/null | head -200`, {
-                encoding: "utf-8", timeout: 5000,
-            });
-            return { success: true, output: output.trim() || "(empty)" };
-        }
-        catch {
-            return { success: false, output: "Failed to list directory recursively" };
-        }
+  const path = resolvePath(input.path);
+  const recursive = input.recursive ?? false;
+  if (!existsSync(path)) return {
+    success: false,
+    output: `Directory not found: ${path}`
+  };
+  if (recursive) {
+    try {
+      const escapedPath = path.replace(/'/g, "'\\''");
+      const output = execSync(`find '${escapedPath}' -maxdepth 4 -not -path '*/.*' 2>/dev/null | head -200`, {
+        encoding: "utf-8",
+        timeout: 5000
+      });
+      return {
+        success: true,
+        output: output.trim() || "(empty)"
+      };
+    } catch {
+      return {
+        success: false,
+        output: "Failed to list directory recursively"
+      };
     }
-    const entries = readdirSync(path, { withFileTypes: true });
-    const lines = entries.map((e) => `${e.isDirectory() ? "[dir]  " : "       "}${e.name}`);
-    return { success: true, output: lines.join("\n") || "(empty directory)" };
+  }
+  const entries = readdirSync(path, {
+    withFileTypes: true
+  });
+  const lines = entries.map(e => `${e.isDirectory() ? "[dir]  " : "       "}${e.name}`);
+  return {
+    success: true,
+    output: lines.join("\n") || "(empty directory)"
+  };
 }
+
 // ============================================================================
 // SEARCH FILES / SEARCH CONTENT (legacy)
 // ============================================================================
+
 export function searchFiles(input) {
-    const pattern = input.pattern.replace(/'/g, "'\\''");
-    const path = resolvePath(input.path).replace(/'/g, "'\\''");
-    try {
-        const output = execSync(`find '${path}' -name '${pattern}' -type f -not -path '*/.*' 2>/dev/null | head -100`, { encoding: "utf-8", timeout: 10000 });
-        return { success: true, output: output.trim() || "No files found" };
-    }
-    catch {
-        return { success: false, output: "Search failed" };
-    }
+  const pattern = input.pattern.replace(/'/g, "'\\''");
+  const path = resolvePath(input.path).replace(/'/g, "'\\''");
+  try {
+    const output = execSync(`find '${path}' -name '${pattern}' -type f -not -path '*/.*' 2>/dev/null | head -100`, {
+      encoding: "utf-8",
+      timeout: 10000
+    });
+    return {
+      success: true,
+      output: output.trim() || "No files found"
+    };
+  } catch {
+    return {
+      success: false,
+      output: "Search failed"
+    };
+  }
 }
 export function searchContent(input) {
-    const query = input.query;
-    const path = resolvePath(input.path);
-    const filePattern = input.file_pattern;
-    let cmd = `grep -rn '${query.replace(/'/g, "'\\''")}' '${path.replace(/'/g, "'\\''")}'`;
-    if (filePattern)
-        cmd += ` --include='${filePattern.replace(/'/g, "'\\''")}'`;
-    cmd += " 2>/dev/null | head -50";
+  const query = input.query;
+  const path = resolvePath(input.path);
+  const filePattern = input.file_pattern;
+  let cmd = `grep -rn '${query.replace(/'/g, "'\\''")}' '${path.replace(/'/g, "'\\''")}'`;
+  if (filePattern) cmd += ` --include='${filePattern.replace(/'/g, "'\\''")}'`;
+  cmd += " 2>/dev/null | head -50";
+  try {
+    const output = execSync(cmd, {
+      encoding: "utf-8",
+      timeout: 10000
+    });
+    return {
+      success: true,
+      output: output.trim() || "No matches found"
+    };
+  } catch {
+    return {
+      success: true,
+      output: "No matches found"
+    };
+  }
+}
+
+// ============================================================================
+// DIFF FILES — unified diff between two files or file vs string
+// ============================================================================
+
+export function diffFiles(input) {
+  const fileA = resolvePath(input.file_a);
+  const fileB = input.file_b ? resolvePath(input.file_b) : undefined;
+  const contentB = input.content_b;
+  const contextLines = input.context_lines ?? 3;
+  if (!existsSync(fileA)) {
+    return {
+      success: false,
+      output: `File not found: ${fileA}`
+    };
+  }
+  let contentA;
+  try {
+    contentA = readFileSync(fileA, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      output: `Failed to read ${fileA}: ${err.message}`
+    };
+  }
+  let compareContent;
+  let labelB;
+  if (fileB) {
+    if (!existsSync(fileB)) {
+      return {
+        success: false,
+        output: `File not found: ${fileB}`
+      };
+    }
     try {
-        const output = execSync(cmd, { encoding: "utf-8", timeout: 10000 });
-        return { success: true, output: output.trim() || "No matches found" };
+      compareContent = readFileSync(fileB, "utf-8");
+      labelB = fileB;
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to read ${fileB}: ${err.message}`
+      };
+    }
+  } else if (contentB !== undefined) {
+    compareContent = contentB;
+    labelB = "(provided content)";
+  } else {
+    return {
+      success: false,
+      output: "Provide either file_b or content_b to compare against"
+    };
+  }
+  const diff = createUnifiedDiff(contentA, compareContent, fileA, labelB, contextLines);
+  return {
+    success: true,
+    output: diff || "Files are identical"
+  };
+}
+function createUnifiedDiff(a, b, labelA, labelB, context) {
+  const linesA = a.split("\n");
+  const linesB = b.split("\n");
+
+  // LCS-based diff
+  const n = linesA.length;
+  const m = linesB.length;
+
+  // For very large files, fall back to simple comparison
+  if (n * m > 10_000_000) {
+    return `--- ${labelA}\n+++ ${labelB}\n@@ Files too large for inline diff (${n} vs ${m} lines). Use an external diff tool. @@\n`;
+  }
+
+  // Build edit script using Myers-like approach via LCS table
+  const dp = Array.from({
+    length: n + 1
+  }, () => new Array(m + 1).fill(0));
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      if (linesA[i] === linesB[j]) {
+        dp[i][j] = dp[i + 1][j + 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+      }
+    }
+  }
+
+  // Build edit operations
+  const ops = [];
+  let i = 0,
+    j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && linesA[i] === linesB[j]) {
+      ops.push({
+        type: "equal",
+        lineA: i,
+        lineB: j,
+        text: linesA[i]
+      });
+      i++;
+      j++;
+    } else if (j < m && (i >= n || dp[i][j + 1] >= dp[i + 1][j])) {
+      ops.push({
+        type: "insert",
+        lineA: i,
+        lineB: j,
+        text: linesB[j]
+      });
+      j++;
+    } else {
+      ops.push({
+        type: "delete",
+        lineA: i,
+        lineB: j,
+        text: linesA[i]
+      });
+      i++;
+    }
+  }
+
+  // Group into hunks with context
+  const hunks = [];
+  let hunkStart = -1;
+  const changeIndices = ops.map((op, idx) => op.type !== "equal" ? idx : -1).filter(x => x >= 0);
+  if (changeIndices.length === 0) return "";
+  let hunkLines = [];
+  let hunkStartA = 0,
+    hunkStartB = 0,
+    hunkCountA = 0,
+    hunkCountB = 0;
+  let lastChangeEnd = -context - 1;
+  for (const ci of changeIndices) {
+    const contextStart = Math.max(0, ci - context);
+    const contextEnd = Math.min(ops.length - 1, ci + context);
+    if (contextStart > lastChangeEnd + 1 && hunkLines.length > 0) {
+      // Flush current hunk
+      hunks.push(`@@ -${hunkStartA + 1},${hunkCountA} +${hunkStartB + 1},${hunkCountB} @@\n${hunkLines.join("\n")}`);
+      hunkLines = [];
+      hunkCountA = 0;
+      hunkCountB = 0;
+      hunkStart = -1;
+    }
+    const rangeStart = hunkLines.length === 0 ? contextStart : Math.min(contextStart, lastChangeEnd + 1);
+    if (hunkStart === -1) {
+      hunkStart = rangeStart;
+      hunkStartA = ops[rangeStart].lineA;
+      hunkStartB = ops[rangeStart].lineB;
     }
-    catch {
-        return { success: true, output: "No matches found" };
+    for (let k = hunkLines.length === 0 ? rangeStart : lastChangeEnd + 1; k <= contextEnd && k < ops.length; k++) {
+      const op = ops[k];
+      if (op.type === "equal") {
+        hunkLines.push(` ${op.text}`);
+        hunkCountA++;
+        hunkCountB++;
+      } else if (op.type === "delete") {
+        hunkLines.push(`-${op.text}`);
+        hunkCountA++;
+      } else {
+        hunkLines.push(`+${op.text}`);
+        hunkCountB++;
+      }
     }
+    lastChangeEnd = contextEnd;
+  }
+  if (hunkLines.length > 0) {
+    hunks.push(`@@ -${hunkStartA + 1},${hunkCountA} +${hunkStartB + 1},${hunkCountB} @@\n${hunkLines.join("\n")}`);
+  }
+  return `--- ${labelA}\n+++ ${labelB}\n${hunks.join("\n")}`;
 }
+//# sourceMappingURL=file-ops.js.map