agent-sh 0.8.0 → 0.10.0

package/dist/utils/diff-renderer.js

@@ -6,7 +6,7 @@
  * Uses token-level LCS for word-level inline diff highlighting.
  */
 import { highlight } from "cli-highlight";
-import { visibleLen } from "./ansi.js";
+import { visibleLen, charWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
 // ── Constants ────────────────────────────────────────────────────
 const SPLIT_MIN_WIDTH = 120;
@@ -223,14 +223,8 @@ function renderSummary(diff) {
         return [`${p.success}+${diff.added} lines${p.reset} ${p.dim}(new file)${p.reset}`];
     return [`${p.success}+${diff.added}${p.reset} ${p.error}-${diff.removed}${p.reset}`];
 }
-// ── Unified mode ─────────────────────────────────────────────────
-function renderUnified(diff, opts) {
-    const useTrueColor = opts.trueColor !== false;
-    const useSyntax = opts.syntaxHighlight !== false;
-    const lang = useSyntax ? detectLanguage(opts.filePath) : undefined;
+function unifiedLayout(diff, opts) {
     const textWidth = opts.width;
-    const output = [];
-    // Compute max line number width across all hunks
     let maxNo = 0;
     for (const hunk of diff.hunks) {
         for (const line of hunk.lines) {
@@ -240,88 +234,90 @@ function renderUnified(diff, opts) {
         }
     }
     const noW = Math.max(String(maxNo).length, 1);
-    // sign(1) + space(1) + lineNo(noW) + space(1) + bar(1) + space(1) = noW + 5
-    const gutterW = noW + 5;
-    const lineTextW = Math.max(1, textWidth - gutterW);
-    const removedPalette = { rowBg: p.errorBg, emphBg: p.errorBgEmph };
-    const addedPalette = { rowBg: p.successBg, emphBg: p.successBgEmph };
-    for (let hunkIdx = 0; hunkIdx < diff.hunks.length; hunkIdx++) {
-        const hunk = diff.hunks[hunkIdx];
-        if (hunkIdx > 0) {
-            output.push(`  ${p.dim}⋯${p.reset}`);
+    return {
+        noW,
+        lineTextW: Math.max(1, textWidth - noW - 5),
+        textWidth,
+        useTrueColor: opts.trueColor !== false,
+        lang: opts.syntaxHighlight !== false ? detectLanguage(opts.filePath) : undefined,
+        removedPalette: { rowBg: p.errorBg, emphBg: p.errorBgEmph },
+        addedPalette: { rowBg: p.successBg, emphBg: p.successBgEmph },
+    };
+}
+function renderUnifiedHunk(hunk, layout) {
+    const { noW, lineTextW, textWidth, useTrueColor, lang, removedPalette, addedPalette } = layout;
+    const out = [];
+    const pairs = findChangePairs(hunk);
+    const renderedAsPartOfPair = new Set();
+    for (let i = 0; i < hunk.lines.length; i++) {
+        const line = hunk.lines[i];
+        const no = String(line.type === "removed" ? (line.oldNo ?? "") : (line.newNo ?? line.oldNo ?? "")).padStart(noW);
+        if (line.type === "context") {
+            const raw = truncateText(line.text, lineTextW);
+            const text = lang ? highlightLine(raw, lang) : raw;
+            out.push(`  ${p.dim}${no} │${p.reset} ${p.dim}${text}${p.reset}`);
+            continue;
         }
-        const pairs = findChangePairs(hunk);
-        const renderedAsPartOfPair = new Set();
-        for (let i = 0; i < hunk.lines.length; i++) {
-            const line = hunk.lines[i];
-            const no = String(line.oldNo ?? line.newNo ?? "").padStart(noW);
-            if (line.type === "context") {
+        if (line.type === "removed") {
+            const pair = pairs.get(i);
+            let removedText;
+            let addedText = null;
+            let addedNo = null;
+            if (pair && pair.removedIdx === i) {
+                const highlighted = highlightInlineChanges(line.text, pair.added.text, removedPalette, addedPalette, useTrueColor, lang);
+                removedText = truncateText(highlighted.old, lineTextW);
+                addedText = truncateText(highlighted.new, lineTextW);
+                addedNo = String(pair.added.newNo ?? "").padStart(noW);
+                renderedAsPartOfPair.add(pair.addedIdx);
+            }
+            else {
                 const raw = truncateText(line.text, lineTextW);
-                const text = lang ? highlightLine(raw, lang) : raw;
-                output.push(`  ${p.dim}${no} │${p.reset} ${p.dim}${text}${p.reset}`);
-                continue;
+                removedText = lang ? highlightLine(raw, lang) : raw;
             }
-            if (line.type === "removed") {
-                const pair = pairs.get(i);
-                let removedText;
-                let addedText = null;
-                let addedNo = null;
-                if (pair && pair.removedIdx === i) {
-                    const highlighted = highlightInlineChanges(line.text, pair.added.text, removedPalette, addedPalette, useTrueColor, lang);
-                    removedText = truncateText(highlighted.old, lineTextW);
-                    addedText = truncateText(highlighted.new, lineTextW);
-                    addedNo = String(pair.added.newNo ?? "").padStart(noW);
-                    renderedAsPartOfPair.add(pair.addedIdx);
-                }
-                else {
-                    // Unpaired removed line — syntax highlight the whole line
-                    const raw = truncateText(line.text, lineTextW);
-                    removedText = lang ? highlightLine(raw, lang) : raw;
-                }
+            if (useTrueColor) {
+                out.push(padToWidth(`${p.errorBg}${p.error}- ${no} │ ${preserveBg(removedText, p.errorBg)}${p.reset}`, textWidth));
+            }
+            else {
+                out.push(`${p.error}- ${no} │ ${removedText}${p.reset}`);
+            }
+            if (addedText !== null && addedNo !== null) {
                 if (useTrueColor) {
-                    const rowContent = `${p.errorBg}${p.error}- ${no} │ ${preserveBg(removedText, p.errorBg)}${p.reset}`;
-                    output.push(padToWidth(rowContent, textWidth));
+                    out.push(padToWidth(`${p.successBg}${p.success}+ ${addedNo} │ ${preserveBg(addedText, p.successBg)}${p.reset}`, textWidth));
                 }
                 else {
-                    output.push(`${p.error}- ${no} │ ${removedText}${p.reset}`);
-                }
-                if (addedText !== null && addedNo !== null) {
-                    if (useTrueColor) {
-                        const rowContent = `${p.successBg}${p.success}+ ${addedNo} │ ${preserveBg(addedText, p.successBg)}${p.reset}`;
-                        output.push(padToWidth(rowContent, textWidth));
-                    }
-                    else {
-                        output.push(`${p.success}+ ${addedNo} │ ${addedText}${p.reset}`);
-                    }
+                    out.push(`${p.success}+ ${addedNo} │ ${addedText}${p.reset}`);
                 }
+            }
+            continue;
+        }
+        if (line.type === "added") {
+            if (renderedAsPartOfPair.has(i))
                 continue;
+            const raw = truncateText(line.text, lineTextW);
+            const text = lang ? highlightLine(raw, lang) : raw;
+            if (useTrueColor) {
+                out.push(padToWidth(`${p.successBg}${p.success}+ ${no} │ ${preserveBg(text, p.successBg)}${p.reset}`, textWidth));
             }
-            if (line.type === "added") {
-                if (renderedAsPartOfPair.has(i))
-                    continue;
-                const raw = truncateText(line.text, lineTextW);
-                const text = lang ? highlightLine(raw, lang) : raw;
-                if (useTrueColor) {
-                    const rowContent = `${p.successBg}${p.success}+ ${no} │ ${preserveBg(text, p.successBg)}${p.reset}`;
-                    output.push(padToWidth(rowContent, textWidth));
-                }
-                else {
-                    output.push(`${p.success}+ ${no} │ ${text}${p.reset}`);
-                }
+            else {
+                out.push(`${p.success}+ ${no} │ ${text}${p.reset}`);
             }
         }
     }
+    return out;
+}
+function renderUnified(diff, opts) {
+    const layout = unifiedLayout(diff, opts);
+    const output = [];
+    for (let hunkIdx = 0; hunkIdx < diff.hunks.length; hunkIdx++) {
+        if (hunkIdx > 0)
+            output.push(`  ${p.dim}⋯${p.reset}`);
+        output.push(...renderUnifiedHunk(diff.hunks[hunkIdx], layout));
+    }
     return output;
 }
-// ── Split (side-by-side) mode ────────────────────────────────────
-function renderSplit(diff, opts) {
-    const useTrueColor = opts.trueColor !== false;
-    const useSyntax = opts.syntaxHighlight !== false;
-    const lang = useSyntax ? detectLanguage(opts.filePath) : undefined;
+function splitLayout(diff, opts) {
     const totalWidth = opts.width;
-    // 3 chars for " │ " separator
     const colWidth = Math.max(1, Math.floor((totalWidth - 3) / 2));
-    // Compute max line number width
     let maxNo = 0;
     for (const hunk of diff.hunks) {
         for (const line of hunk.lines) {
@@ -331,78 +327,87 @@ function renderSplit(diff, opts) {
         }
     }
     const noW = Math.max(String(maxNo).length, 1);
-    // lineNo(noW) + space(1) + bar(1) + space(1) = noW + 3
-    const textW = Math.max(1, colWidth - noW - 3);
-    const removedPalette = { rowBg: p.errorBg, emphBg: p.errorBgEmph };
-    const addedPalette = { rowBg: p.successBg, emphBg: p.successBgEmph };
-    const output = [];
-    // Column header
-    const leftHeader = padToWidth(`${p.dim}${"─".repeat(colWidth)}${p.reset}`, colWidth);
-    const rightHeader = padToWidth(`${p.dim}${"─".repeat(colWidth)}${p.reset}`, colWidth);
-    output.push(`${leftHeader} ${p.dim}│${p.reset} ${rightHeader}`);
-    for (let hunkIdx = 0; hunkIdx < diff.hunks.length; hunkIdx++) {
-        const hunk = diff.hunks[hunkIdx];
-        if (hunkIdx > 0) {
-            output.push(`${p.dim}${" ".repeat(colWidth)} │ ${" ".repeat(colWidth)}${p.reset}`);
-            output.push(`${p.dim}${"·".repeat(colWidth)} │ ${"·".repeat(colWidth)}${p.reset}`);
-        }
-        const rows = buildSplitRows(hunk);
-        for (const row of rows) {
-            const leftNo = row.left
-                ? String(row.left.oldNo ?? row.left.newNo ?? "").padStart(noW)
-                : " ".repeat(noW);
-            const rightNo = row.right
-                ? String(row.right.newNo ?? row.right.oldNo ?? "").padStart(noW)
-                : " ".repeat(noW);
-            let leftText = row.left ? truncateText(row.left.text, textW) : "";
-            let rightText = row.right ? truncateText(row.right.text, textW) : "";
-            // Apply inline highlighting for change pairs
-            if (row.left && row.right && row.left.type === "removed" && row.right.type === "added") {
-                const highlighted = highlightInlineChanges(row.left.text, row.right.text, removedPalette, addedPalette, useTrueColor, lang);
-                leftText = truncateText(highlighted.old, textW);
-                rightText = truncateText(highlighted.new, textW);
-            }
-            else {
-                // Non-pair lines: apply syntax highlighting
-                if (lang) {
-                    if (leftText)
-                        leftText = highlightLine(leftText, lang);
-                    if (rightText)
-                        rightText = highlightLine(rightText, lang);
-                }
-            }
-            let leftCol;
-            let rightCol;
-            if (!row.left || row.left.type === "context") {
-                leftCol = padToWidth(`${p.dim}${leftNo} │${p.reset} ${p.dim}${leftText}${p.reset}`, colWidth);
-            }
-            else if (row.left.type === "removed") {
-                if (useTrueColor) {
-                    leftCol = padToWidth(`${p.errorBg}${p.error}${leftNo} │ ${preserveBg(leftText, p.errorBg)}${p.reset}`, colWidth);
-                }
-                else {
-                    leftCol = padToWidth(`${p.error}${leftNo} │ ${leftText}${p.reset}`, colWidth);
-                }
+    return {
+        colWidth,
+        noW,
+        textW: Math.max(1, colWidth - noW - 3),
+        useTrueColor: opts.trueColor !== false,
+        lang: opts.syntaxHighlight !== false ? detectLanguage(opts.filePath) : undefined,
+        removedPalette: { rowBg: p.errorBg, emphBg: p.errorBgEmph },
+        addedPalette: { rowBg: p.successBg, emphBg: p.successBgEmph },
+    };
+}
+function renderSplitHunk(hunk, layout) {
+    const { colWidth, noW, textW, useTrueColor, lang, removedPalette, addedPalette } = layout;
+    const out = [];
+    const rows = buildSplitRows(hunk);
+    for (const row of rows) {
+        const leftNo = row.left
+            ? String(row.left.oldNo ?? row.left.newNo ?? "").padStart(noW)
+            : " ".repeat(noW);
+        const rightNo = row.right
+            ? String(row.right.newNo ?? row.right.oldNo ?? "").padStart(noW)
+            : " ".repeat(noW);
+        let leftText = row.left ? truncateText(row.left.text, textW) : "";
+        let rightText = row.right ? truncateText(row.right.text, textW) : "";
+        if (row.left && row.right && row.left.type === "removed" && row.right.type === "added") {
+            const highlighted = highlightInlineChanges(row.left.text, row.right.text, removedPalette, addedPalette, useTrueColor, lang);
+            leftText = truncateText(highlighted.old, textW);
+            rightText = truncateText(highlighted.new, textW);
+        }
+        else if (lang) {
+            if (leftText)
+                leftText = highlightLine(leftText, lang);
+            if (rightText)
+                rightText = highlightLine(rightText, lang);
+        }
+        let leftCol;
+        let rightCol;
+        if (!row.left || row.left.type === "context") {
+            leftCol = padToWidth(`${p.dim}${leftNo} │${p.reset} ${p.dim}${leftText}${p.reset}`, colWidth);
+        }
+        else if (row.left.type === "removed") {
+            if (useTrueColor) {
+                leftCol = padToWidth(`${p.errorBg}${p.error}${leftNo} │ ${preserveBg(leftText, p.errorBg)}${p.reset}`, colWidth);
             }
             else {
-                leftCol = padToWidth(`${p.dim}${leftNo} │${p.reset} ${leftText}`, colWidth);
+                leftCol = padToWidth(`${p.error}${leftNo} │ ${leftText}${p.reset}`, colWidth);
             }
-            if (!row.right || row.right.type === "context") {
-                rightCol = padToWidth(`${p.dim}${rightNo} │${p.reset} ${p.dim}${rightText}${p.reset}`, colWidth);
-            }
-            else if (row.right.type === "added") {
-                if (useTrueColor) {
-                    rightCol = padToWidth(`${p.successBg}${p.success}${rightNo} │ ${preserveBg(rightText, p.successBg)}${p.reset}`, colWidth);
-                }
-                else {
-                    rightCol = padToWidth(`${p.success}${rightNo} │ ${rightText}${p.reset}`, colWidth);
-                }
+        }
+        else {
+            leftCol = padToWidth(`${p.dim}${leftNo} │${p.reset} ${leftText}`, colWidth);
+        }
+        if (!row.right || row.right.type === "context") {
+            rightCol = padToWidth(`${p.dim}${rightNo} │${p.reset} ${p.dim}${rightText}${p.reset}`, colWidth);
+        }
+        else if (row.right.type === "added") {
+            if (useTrueColor) {
+                rightCol = padToWidth(`${p.successBg}${p.success}${rightNo} │ ${preserveBg(rightText, p.successBg)}${p.reset}`, colWidth);
             }
             else {
-                rightCol = padToWidth(`${p.dim}${rightNo} │${p.reset} ${rightText}`, colWidth);
+                rightCol = padToWidth(`${p.success}${rightNo} │ ${rightText}${p.reset}`, colWidth);
             }
-            output.push(`${leftCol} ${p.dim}│${p.reset} ${rightCol}`);
         }
+        else {
+            rightCol = padToWidth(`${p.dim}${rightNo} │${p.reset} ${rightText}`, colWidth);
+        }
+        out.push(`${leftCol} ${p.dim}│${p.reset} ${rightCol}`);
+    }
+    return out;
+}
+function renderSplit(diff, opts) {
+    const layout = splitLayout(diff, opts);
+    const output = [];
+    // Column header
+    const leftHeader = padToWidth(`${p.dim}${"─".repeat(layout.colWidth)}${p.reset}`, layout.colWidth);
+    const rightHeader = padToWidth(`${p.dim}${"─".repeat(layout.colWidth)}${p.reset}`, layout.colWidth);
+    output.push(`${leftHeader} ${p.dim}│${p.reset} ${rightHeader}`);
+    for (let hunkIdx = 0; hunkIdx < diff.hunks.length; hunkIdx++) {
+        if (hunkIdx > 0) {
+            output.push(`${p.dim}${" ".repeat(layout.colWidth)} │ ${" ".repeat(layout.colWidth)}${p.reset}`);
+            output.push(`${p.dim}${"·".repeat(layout.colWidth)} │ ${"·".repeat(layout.colWidth)}${p.reset}`);
+        }
+        output.push(...renderSplitHunk(diff.hunks[hunkIdx], layout));
     }
     return output;
 }
@@ -439,6 +444,35 @@ function buildSplitRows(hunk) {
     }
     return rows;
 }
+async function renderUnifiedAsync(diff, opts, yieldFn) {
+    const layout = unifiedLayout(diff, opts);
+    const output = [];
+    for (let hunkIdx = 0; hunkIdx < diff.hunks.length; hunkIdx++) {
+        if (hunkIdx > 0)
+            await yieldFn();
+        if (hunkIdx > 0)
+            output.push(`  ${p.dim}⋯${p.reset}`);
+        output.push(...renderUnifiedHunk(diff.hunks[hunkIdx], layout));
+    }
+    return output;
+}
+async function renderSplitAsync(diff, opts, yieldFn) {
+    const layout = splitLayout(diff, opts);
+    const output = [];
+    const leftHeader = padToWidth(`${p.dim}${"─".repeat(layout.colWidth)}${p.reset}`, layout.colWidth);
+    const rightHeader = padToWidth(`${p.dim}${"─".repeat(layout.colWidth)}${p.reset}`, layout.colWidth);
+    output.push(`${leftHeader} ${p.dim}│${p.reset} ${rightHeader}`);
+    for (let hunkIdx = 0; hunkIdx < diff.hunks.length; hunkIdx++) {
+        if (hunkIdx > 0)
+            await yieldFn();
+        if (hunkIdx > 0) {
+            output.push(`${p.dim}${" ".repeat(layout.colWidth)} │ ${" ".repeat(layout.colWidth)}${p.reset}`);
+            output.push(`${p.dim}${"·".repeat(layout.colWidth)} │ ${"·".repeat(layout.colWidth)}${p.reset}`);
+        }
+        output.push(...renderSplitHunk(diff.hunks[hunkIdx], layout));
+    }
+    return output;
+}
 // ── Utilities ────────────────────────────────────────────────────
 /**
  * Truncate text to fit within maxWidth visible characters.
@@ -451,11 +485,11 @@ function truncateText(text, maxWidth) {
         return text;
     if (maxWidth <= 1)
         return "…";
-    // Walk through the string, tracking visible characters
+    // Advance by visible width (CJK = 2), skipping ANSI sequences.
+    // Reserve one column for the trailing ellipsis.
     let visible = 0;
     let i = 0;
     while (i < text.length && visible < maxWidth - 1) {
-        // Check for ANSI escape sequence
         if (text[i] === "\x1b" && text[i + 1] === "[") {
             const end = text.indexOf("m", i);
             if (end !== -1) {
@@ -463,11 +497,100 @@ function truncateText(text, maxWidth) {
                 continue;
             }
         }
-        visible++;
-        i++;
+        const cp = text.codePointAt(i) ?? 0;
+        const cw = charWidth(cp);
+        if (visible + cw > maxWidth - 1)
+            break;
+        visible += cw;
+        i += cp > 0xffff ? 2 : 1;
     }
     return text.slice(0, i) + p.reset + "…";
 }
+// ── Truncation ──────────────────────────────────────────────────
+/**
+ * Trim context lines from hunks so the rendered output fits within a budget.
+ * Change lines are never removed — only the surrounding context shrinks.
+ */
+function trimHunksToFit(hunks, maxLines) {
+    // Count change lines across all hunks
+    let changeCount = 0;
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            if (line.type !== "context")
+                changeCount++;
+        }
+    }
+    // Separators between hunks
+    const separators = Math.max(0, hunks.length - 1);
+    // How many context lines can we afford?
+    const contextBudget = Math.max(0, maxLines - changeCount - separators);
+    // Count total context to see if trimming is needed
+    let totalContext = 0;
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            if (line.type === "context")
+                totalContext++;
+        }
+    }
+    if (totalContext <= contextBudget)
+        return hunks;
+    // Determine how many context lines to keep per side of each change.
+    // Binary-search for the largest per-side context that fits.
+    let lo = 0;
+    let hi = 3; // original context size from groupHunks
+    while (lo < hi) {
+        const mid = Math.ceil((lo + hi) / 2);
+        if (countContextWithLimit(hunks, mid) <= contextBudget)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return rebuildHunks(hunks, lo);
+}
+/** Count how many context lines remain if we keep at most `ctx` per side of each change. */
+function countContextWithLimit(hunks, ctx) {
+    let count = 0;
+    for (const hunk of hunks) {
+        const lines = hunk.lines;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].type !== "context")
+                continue;
+            // Keep this context line if it's within `ctx` of any change
+            let nearChange = false;
+            for (let d = 1; d <= ctx; d++) {
+                if ((i - d >= 0 && lines[i - d].type !== "context") ||
+                    (i + d < lines.length && lines[i + d].type !== "context")) {
+                    nearChange = true;
+                    break;
+                }
+            }
+            if (nearChange)
+                count++;
+        }
+    }
+    return count;
+}
+/** Rebuild hunks keeping only context lines within `ctx` distance of a change. */
+function rebuildHunks(hunks, ctx) {
+    return hunks.map((hunk) => {
+        const lines = hunk.lines;
+        const kept = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].type !== "context") {
+                kept.push(lines[i]);
+                continue;
+            }
+            for (let d = 1; d <= ctx; d++) {
+                if ((i - d >= 0 && lines[i - d].type !== "context") ||
+                    (i + d < lines.length && lines[i + d].type !== "context")) {
+                    kept.push(lines[i]);
+                    break;
+                }
+            }
+        }
+        return { lines: kept };
+    });
+}
 // ── Public API ───────────────────────────────────────────────────
 /** Select display mode based on available terminal width. */
 export function selectMode(width) {
@@ -487,16 +610,19 @@ export function renderDiff(diff, opts) {
     if (mode === "summary") {
         return [header, ...renderSummary(diff)];
     }
+    // Trim context lines from hunks if the diff would exceed the budget,
+    // so that actual changes are always visible.
+    const trimmed = { ...diff, hunks: trimHunksToFit(diff.hunks, maxLines) };
     let bodyLines;
     switch (mode) {
         case "split":
-            bodyLines = renderSplit(diff, opts);
+            bodyLines = renderSplit(trimmed, opts);
             break;
         case "unified":
-            bodyLines = renderUnified(diff, opts);
+            bodyLines = renderUnified(trimmed, opts);
             break;
     }
-    // Truncation
+    // Final safety net — if still over budget, simple tail truncation.
     if (bodyLines.length > maxLines) {
         const overflow = bodyLines.length - maxLines;
         bodyLines = bodyLines.slice(0, maxLines);
@@ -504,3 +630,43 @@ export function renderDiff(diff, opts) {
     }
     return [header, ...bodyLines];
 }
+/**
+ * Async variant of renderDiff that yields to the event loop between hunks.
+ * Use when rendering in a context where a spinner or other UI needs to stay
+ * responsive (e.g. showing a large diff during a permission prompt).
+ *
+ * @param onLines - Callback invoked with each batch of rendered lines as they
+ *                  are produced. Allows progressive/streaming display.
+ */
+export async function renderDiffAsync(diff, opts, onLines) {
+    if (diff.isIdentical) {
+        onLines([`${p.dim}(no changes)${p.reset}`]);
+        return;
+    }
+    const mode = opts.mode ?? selectMode(opts.width);
+    const maxLines = opts.maxLines ?? 50;
+    const header = buildHeader(diff, opts.filePath);
+    if (mode === "summary") {
+        onLines([header, ...renderSummary(diff)]);
+        return;
+    }
+    // Trim context lines from hunks if the diff would exceed the budget
+    const trimmed = { ...diff, hunks: trimHunksToFit(diff.hunks, maxLines) };
+    const yieldFn = () => new Promise(r => setImmediate(r));
+    let bodyLines;
+    switch (mode) {
+        case "split":
+            bodyLines = await renderSplitAsync(trimmed, opts, yieldFn);
+            break;
+        case "unified":
+            bodyLines = await renderUnifiedAsync(trimmed, opts, yieldFn);
+            break;
+    }
+    // Final safety net — if still over budget, simple tail truncation.
+    if (bodyLines.length > maxLines) {
+        const overflow = bodyLines.length - maxLines;
+        bodyLines = bodyLines.slice(0, maxLines);
+        bodyLines.push(`${p.dim}… ${overflow} more lines${p.reset}`);
+    }
+    onLines([header, ...bodyLines]);
+}

package/dist/utils/diff.d.ts

@@ -1,5 +1,12 @@
 /**
- * Lightweight LCS-based line diff for file modification previews.
+ * Line-level diff computation, powered by the `diff` npm package.
+ *
+ * Exposes a unified `DiffResult` interface consumed by the diff renderer.
+ * Three entry points cover the main use cases:
+ *
+ *   computeDiff       — full-file diff (write_file, or when edit region can't be located)
+ *   computeEditDiff   — edit_file: locates the edit region, builds the new file, full diff
+ *   computeInputDiff  — fast preview: diffs only old_text vs new_text, no file I/O
  */
 export interface DiffLine {
     type: "context" | "added" | "removed";
@@ -19,6 +26,18 @@ export interface DiffResult {
 }
 /**
  * Compute a line-level diff between old and new file content.
- * Returns grouped hunks with 3 lines of context around each change.
  */
 export declare function computeDiff(oldText: string | null, newText: string): DiffResult;
+/**
+ * Compute a diff for an edit operation where we know the old/new text.
+ * Locates the edit region(s) in the file, constructs the full new file,
+ * then diffs the whole thing so line numbers are file-relative.
+ */
+export declare function computeEditDiff(oldFileText: string, editOld: string, editNew: string, replaceAll?: boolean): DiffResult;
+/**
+ * Diff two edit strings directly — no file read needed.
+ * Line numbers are relative to the edit region, not the file.
+ * Use for permission prompt previews where speed matters more than
+ * exact file-relative line numbers.
+ */
+export declare function computeInputDiff(oldText: string, newText: string): DiffResult;