atom-agent 1.0.0 → 1.2.0

package/dist/tools/web.js

@@ -5,7 +5,7 @@ import * as net from "node:net";
 import { loadAtomConfig } from "../config.js";
 import { classifyIp, defaultNetworkPolicy, isRedirectStatus, zoneAllows, zoneForAddresses, } from "../policy.js";
 import { appendOverflow } from "./overflow.js";
-import { err, READ_CHAR_CAP } from "./shared.js";
+import { err, READ_CHAR_CAP, truncateHead } from "./shared.js";
 // ---- Web tools (webfetch retrieval / websearch discovery) ----
 const WEB_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36";
 const WEBFETCH_DOWNLOAD_CAP = 1024 * 1024; // ~1MB download cap
@@ -318,12 +318,12 @@ export async function webfetchTool(args, opts) {
             notes.push("[truncated: download exceeded ~1MB]");
         if (text.length > READ_CHAR_CAP) {
             const full = text;
-            const head = full.slice(0, READ_CHAR_CAP);
-            text = head;
-            notes.push("[truncated: output exceeded 64KB]");
+            const t = truncateHead(full, READ_CHAR_CAP, "\n[truncated: output exceeded 64KB]");
+            text = t.head;
+            notes.push(t.note.replace(/^\n/, ""));
             // Single spill: recover the pointer line from the composed tail.
-            const tailed = appendOverflow(head, "\n[truncated: output exceeded 64KB]", "converted page text", full);
-            const overflowLine = tailed.slice((head + "\n[truncated: output exceeded 64KB]\n").length);
+            const tailed = appendOverflow(t.head, t.note, "converted page text", full);
+            const overflowLine = tailed.slice((t.head + t.note + "\n").length);
             if (overflowLine.startsWith("[overflow:"))
                 notes.push(overflowLine);
         }

package/dist/tools.js

@@ -10,8 +10,11 @@
 // `"../src/tools.js"` import keeps working untouched.
 export * from "./tools/filesystem.js";
 export * from "./tools/fingerprints.js";
+export * from "./tools/dir-cache.js";
 export * from "./tools/overflow.js";
+export * from "./tools/read-cache.js";
 export * from "./tools/registry.js";
+export * from "./tools/ripgrep.js";
 export * from "./tools/search.js";
 export * from "./tools/shared.js";
 export * from "./tools/shell.js";

package/dist/ui/diff-panel.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { computeDiff } from "./diff.js";
+import { SideBySideDiffView } from "./side-by-side.js";
+import { theme } from "./theme.js";
+import { LIST_WINDOW, windowedList } from "./tool-inspector.js";
+// Cap for the panel detail (hunk headers excluded): full-file writes can
+// be large — the head reviews, the trailer names the remainder, the file
+// on disk is the whole truth.
+export const DIFF_PANEL_MAX_LINES = 200;
+// Group committed session previews by file: latest preview per path
+// wins (a later edit supersedes the earlier view of the same file),
+// first-seen path order kept. Previews without a path are ungroupable
+// (they still render inline in the transcript) and skipped here.
+// Pure — shared by the App opener and unit tests.
+export function groupSessionDiffs(turns) {
+    const byPath = new Map();
+    for (const t of turns) {
+        const d = t.diff;
+        if (!d || !d.path)
+            continue;
+        byPath.set(d.path, d);
+    }
+    const files = [];
+    for (const [p, d] of byPath) {
+        let adds = 0;
+        let dels = 0;
+        try {
+            const r = computeDiff(d.oldText, d.newText);
+            adds = r.adds;
+            dels = r.dels;
+        }
+        catch {
+            // A preview that fails to diff still lists (counts stay 0) —
+            // review must never crash on data it already rendered inline.
+        }
+        files.push({ path: p, oldText: d.oldText, newText: d.newText, lang: d.lang, adds, dels });
+    }
+    return files;
+}
+export function DiffPanel({ files, index, expanded }) {
+    const sel = Math.max(0, Math.min(index, files.length - 1));
+    const rec = files[sel];
+    if (!rec)
+        return null;
+    if (!expanded) {
+        const win = windowedList(files, sel, LIST_WINDOW);
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Session changes \u2014 select a file to review (Enter expands, Esc closes):" }), win.above > 0 ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " ", win.above, " more"] })) : null, win.slice.map((r, k) => {
+                    const i = win.start + k;
+                    const hi = i === sel;
+                    return (_jsxs(Text, { color: hi ? theme.color.selection : undefined, children: [hi ? `${theme.symbol.select} ` : theme.spacing.rowIndent, "+", r.adds, " \u2212", r.dels, " ", r.path] }, r.path));
+                }), win.below > 0 ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreBelow, " ", win.below, " more"] })) : null, _jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, "/", theme.symbol.moreBelow, " move \u00B7 Enter expands \u00B7 Esc closes"] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [rec.path, _jsxs(Text, { dimColor: true, children: [" ", theme.symbol.separator, " +", rec.adds, " \u2212", rec.dels] })] }), _jsx(Text, { dimColor: true, children: theme.symbol.rule.repeat(32) }), _jsx(SideBySideDiffView, { oldText: rec.oldText, newText: rec.newText, lang: rec.lang, maxRows: DIFF_PANEL_MAX_LINES }), _jsx(Text, { dimColor: true, children: theme.symbol.rule.repeat(32) }), _jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, "/", theme.symbol.moreBelow, " prev/next file \u00B7 Enter collapses \u00B7 Esc closes"] })] }));
+}

package/dist/ui/diff-view.js

@@ -0,0 +1,117 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Approval-time + transcript diff view: the unified, word-highlighted,
+// syntax-colored preview for write/edit calls.
+//
+// Claude-Code parity, ATOM-ified: hunk headers + `-`/`+` lines +
+// changed-word backgrounds + syntax foregrounds (ui/highlight, zero-dep),
+// one <Text> per run (no per-character nodes), word diff + highlighting
+// memoized/cached so the 1s busy tick never recomputes. Long lines are
+// never truncated (Ink wraps; copy/paste stays intact) — only hunk COUNT
+// is capped via maxLines so the modal stays compact. All paint comes from
+// ui/theme tokens (Ink supports color + backgroundColor on Text — verified
+// against the installed Ink 7 typings).
+import React from "react";
+import { Box, Text } from "ink";
+import { computeDiff } from "./diff.js";
+import { highlightLine } from "./highlight.js";
+import { theme } from "./theme.js";
+function syntaxColor(kind) {
+    if (kind === "keyword")
+        return theme.color.synKeyword;
+    if (kind === "string")
+        return theme.color.synString;
+    if (kind === "number")
+        return theme.color.synNumber;
+    return undefined; // comment → dim, plain → line paint
+}
+// One diff line body: word-diff runs sub-split by syntax spans. Both
+// segmentations tile the same line text, so walking them together with
+// an offset cursor paints every char exactly once (text integrity is
+// pinned by tests — highlighting must never alter content). Exported:
+// the side-by-side view (ui/side-by-side) reuses it per pane cell.
+//
+// Memoized: props are (lineText, runs, base, lang) — `runs` keeps identity
+// from the parent's useMemo'd diff, and highlightLine is itself line-cached,
+// so unrelated parent renders (ticks, keystrokes, appends elsewhere) skip
+// both the walk and the tokenize lookup.
+export const LineBody = React.memo(function LineBody({ lineText, runs, base, lang, }) {
+    const baseColor = base === "add" ? theme.color.success : theme.color.toolError;
+    const hlBg = base === "add" ? "green" : "red";
+    const langKnown = lang === "c" || lang === "py" || lang === "sh" || lang === "data";
+    const syn = langKnown ? highlightLine(lineText, lang) : [];
+    const nodes = [];
+    let offset = 0;
+    let synIdx = 0;
+    runs.forEach((r, k) => {
+        const runStart = offset;
+        const runEnd = offset + r.text.length;
+        offset = runEnd;
+        if (r.changed) {
+            // Changed words keep the high-contrast background treatment —
+            // syntax hues would muddy the signal.
+            nodes.push(_jsx(Text, { backgroundColor: hlBg, color: "black", bold: true, children: r.text }, k));
+            // Advance the syntax cursor past this run so later runs align.
+            while (synIdx < syn.length && syn[synIdx].end <= runEnd)
+                synIdx += 1;
+            return;
+        }
+        // Unchanged text: paint syntax spans; plain spans inherit the line
+        // paint (base tint for unknown files, terminal default when the
+        // language is known — the +/- prefix carries line identity there).
+        // Skip syntax runs that end before this run starts (can happen only
+        // if segmentations disagree — defensive, never expected).
+        while (synIdx < syn.length && syn[synIdx].end <= runStart)
+            synIdx += 1;
+        let si = synIdx;
+        const parts = [];
+        let pk = 0;
+        while (si < syn.length && syn[si].start < runEnd) {
+            const s = syn[si];
+            const a = Math.max(s.start, runStart);
+            const b = Math.min(s.end, runEnd);
+            if (b > a) {
+                const piece = r.text.slice(a - runStart, b - runStart);
+                const fg = syntaxColor(s.kind) ?? (langKnown ? undefined : baseColor);
+                parts.push(s.kind === "comment" ? (_jsx(Text, { dimColor: true, children: piece }, pk++)) : (_jsx(Text, { color: fg, children: piece }, pk++)));
+            }
+            if (s.end <= runEnd)
+                si += 1;
+            else
+                break;
+        }
+        if (parts.length === 0) {
+            parts.push(_jsx(Text, { color: langKnown ? undefined : baseColor, children: r.text }, pk++));
+        }
+        nodes.push(_jsx(Text, { children: parts }, k));
+    });
+    return _jsx(Text, { color: langKnown ? undefined : baseColor, children: nodes });
+});
+function DiffViewInner({ oldText, newText, lang = null, maxLines = Infinity }) {
+    const diff = React.useMemo(() => computeDiff(oldText, newText), [oldText, newText]);
+    if (diff.skipped) {
+        return _jsx(Text, { dimColor: true, children: diff.skipped });
+    }
+    if (diff.hunks.length === 0) {
+        return _jsx(Text, { dimColor: true, children: "(no visible changes)" });
+    }
+    let bodyLines = 0;
+    const overflow = (() => {
+        let total = 0;
+        for (const h of diff.hunks)
+            total += h.lines.length;
+        return Math.max(0, total - maxLines);
+    })();
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [diff.isNewFile ? "new file " : "", "+", diff.adds, " \u2212", diff.dels] }), diff.hunks.map((h, hi) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["@@ -", h.oldStart, ",", h.oldLines, " +", h.newStart, ",", h.newLines, " @@"] }), h.lines.map((ln, k) => {
+                        bodyLines += 1;
+                        if (bodyLines > maxLines)
+                            return null;
+                        if (ln.kind === "context") {
+                            return (_jsxs(Text, { dimColor: true, children: ["  ", ln.text.length > 0 ? ln.text : " "] }, k));
+                        }
+                        if (ln.kind === "del") {
+                            return (_jsxs(Text, { children: [_jsx(Text, { color: theme.color.toolError, children: "- " }), _jsx(LineBody, { lineText: ln.text, runs: ln.runs, base: "del", lang: lang }), ln.text.length === 0 ? " " : null] }, k));
+                        }
+                        return (_jsxs(Text, { children: [_jsx(Text, { color: theme.color.success, children: "+ " }), _jsx(LineBody, { lineText: ln.text, runs: ln.runs, base: "add", lang: lang }), ln.text.length === 0 ? " " : null] }, k));
+                    })] }, hi))), overflow > 0 ? _jsxs(Text, { dimColor: true, children: ["\u2026 ", overflow, " more line", overflow === 1 ? "" : "s"] }) : null, diff.truncated ? _jsx(Text, { dimColor: true, children: "(diff truncated at 400 changed lines)" }) : null] }));
+}
+export const DiffView = React.memo(DiffViewInner);

package/dist/ui/diff.js

@@ -0,0 +1,422 @@
+// Mirrors Claude's StructuredDiffFallback threshold: when the share of
+// changed words in a paired line exceeds this, word highlighting would
+// be noise — render the whole line flat instead.
+export const CHANGE_THRESHOLD = 0.4;
+// Mirrors Claude's DiffDetailView guards.
+export const MAX_FILE_BYTES = 1_000_000;
+export const MAX_CHANGED_LINES = 400;
+export const DIFF_CONTEXT = 3;
+// Worst-case guards for the O(ND) Myers pass + O(w1*w2) word pass.
+const MAX_MYERS_LINES = 1000;
+const MAX_WORD_TOKENS = 200;
+function splitLines(s) {
+    if (s === "")
+        return [];
+    return s.replace(/\r\n?/g, "\n").split("\n");
+}
+function isBinary(s) {
+    return s.includes("\0");
+}
+// Tokenize into words + whitespace runs (whitespace kept so runs
+// rejoin byte-identical to the source line).
+function tokenize(line) {
+    const out = line.split(/(\s+)/g).filter((t) => t.length > 0);
+    return out.length > 0 ? out : [line];
+}
+function isWord(tok) {
+    return /\S/.test(tok);
+}
+// LCS table for small sequences (lines or words). Returns the matched
+// index pairs in order.
+function lcsPairs(a, b, eq) {
+    const n = a.length;
+    const m = b.length;
+    if (n === 0 || m === 0)
+        return [];
+    // Uint16 caps at 65535 — sequences here are small (words) or
+    // Myers-capped (lines); guard anyway.
+    const use32 = n > 6000 || m > 6000;
+    const w = m + 1;
+    const dp = use32 ? new Uint32Array((n + 1) * w) : new Uint16Array((n + 1) * w);
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            const v = eq(a[i - 1], b[j - 1])
+                ? dp[(i - 1) * w + (j - 1)] + 1
+                : Math.max(dp[(i - 1) * w + j], dp[i * w + (j - 1)]);
+            dp[i * w + j] = v > 65535 && !use32 ? 65535 : v;
+        }
+    }
+    const pairs = [];
+    let i = n;
+    let j = m;
+    while (i > 0 && j > 0) {
+        if (eq(a[i - 1], b[j - 1])) {
+            pairs.push([i - 1, j - 1]);
+            i -= 1;
+            j -= 1;
+        }
+        else if (dp[(i - 1) * w + j] >= dp[i * w + (j - 1)]) {
+            i -= 1;
+        }
+        else {
+            j -= 1;
+        }
+    }
+    pairs.reverse();
+    return pairs;
+}
+// Myers O(ND) line diff with a hard cell budget — falls back to a
+// single del/add block when the files are too big to trace exactly.
+// Returns ops over old lines (a) and new lines (b).
+function myersOps(a, b) {
+    const n = a.length;
+    const m = b.length;
+    if (n === 0)
+        return b.map((_, j) => ({ kind: "add", b: j }));
+    if (m === 0)
+        return a.map((_, i) => ({ kind: "del", a: i }));
+    if (n + m > MAX_MYERS_LINES) {
+        // Linear fallback: common prefix/suffix, middle is one block.
+        let pre = 0;
+        while (pre < n && pre < m && a[pre] === b[pre])
+            pre += 1;
+        let suf = 0;
+        while (suf < n - pre && suf < m - pre && a[n - 1 - suf] === b[m - 1 - suf])
+            suf += 1;
+        const ops = [];
+        for (let i = 0; i < pre; i++)
+            ops.push({ kind: "same", a: i, b: i });
+        for (let i = pre; i < n - suf; i++)
+            ops.push({ kind: "del", a: i });
+        for (let j = pre; j < m - suf; j++)
+            ops.push({ kind: "add", b: j });
+        for (let k = 0; k < suf; k++)
+            ops.push({ kind: "same", a: n - suf + k, b: m - suf + k });
+        return ops;
+    }
+    // Exact Myers when small: LCS pairs, then expand to ops.
+    const pairs = lcsPairs(a, b, (x, y) => x === y);
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    for (const [pi, pj] of pairs) {
+        while (i < pi)
+            ops.push({ kind: "del", a: i++ });
+        while (j < pj)
+            ops.push({ kind: "add", b: j++ });
+        ops.push({ kind: "same", a: i++, b: j++ });
+    }
+    while (i < n)
+        ops.push({ kind: "del", a: i++ });
+    while (j < m)
+        ops.push({ kind: "add", b: j++ });
+    return ops;
+}
+function flatRuns(text) {
+    return text === "" ? [] : [{ text, changed: false }];
+}
+// Word-level pairing for one del/add line pair. Returns runs for both
+// sides; falls back to flat (line-level) when the pair is too big or
+// too changed (CHANGE_THRESHOLD). Exported: the side-by-side builder
+// below and the cell renderer (ui/diff-view) share it.
+export function wordRuns(delText, addText) {
+    const dt = tokenize(delText);
+    const at = tokenize(addText);
+    if (dt.length > MAX_WORD_TOKENS || at.length > MAX_WORD_TOKENS) {
+        return { del: flatRuns(delText), add: flatRuns(addText) };
+    }
+    const pairs = lcsPairs(dt, at, (x, y) => x === y);
+    const delKeep = new Set(pairs.map(([i]) => i));
+    const addKeep = new Set(pairs.map(([, j]) => j));
+    const dw = dt.filter((t, i) => !delKeep.has(i) && isWord(t)).length;
+    const aw = at.filter((t, j) => !addKeep.has(j) && isWord(t)).length;
+    // Share of changed words over ALL tokens (whitespace included — it
+    // almost always matches, so a single changed word in a normal line
+    // stays well under the threshold while near-total rewrites exceed
+    // it and fall back to line-level).
+    const denom = Math.max(dt.length, at.length, 1);
+    if ((dw + aw) / denom > CHANGE_THRESHOLD) {
+        return { del: flatRuns(delText), add: flatRuns(addText) };
+    }
+    const build = (toks, keep) => {
+        const runs = [];
+        for (let k = 0; k < toks.length; k++) {
+            const changed = !keep.has(k) && isWord(toks[k]);
+            const prev = runs[runs.length - 1];
+            if (prev && prev.changed === changed)
+                prev.text += toks[k];
+            else
+                runs.push({ text: toks[k], changed });
+        }
+        return runs;
+    };
+    return { del: build(dt, delKeep), add: build(at, addKeep) };
+}
+export function computeDiff(oldText, newText) {
+    const empty = {
+        hunks: [],
+        adds: 0,
+        dels: 0,
+        truncated: false,
+        skipped: null,
+        isNewFile: oldText === null,
+    };
+    if (isBinary(newText) || (oldText !== null && isBinary(oldText))) {
+        return { ...empty, skipped: "binary file — diff skipped" };
+    }
+    if (newText.length > MAX_FILE_BYTES || (oldText !== null && oldText.length > MAX_FILE_BYTES)) {
+        return { ...empty, skipped: "file over 1MB — diff skipped" };
+    }
+    const oldLines = oldText === null ? [] : splitLines(oldText);
+    const newLines = splitLines(newText);
+    if (oldText !== null && oldText === newText)
+        return empty;
+    const ops = myersOps(oldLines, newLines);
+    const raw = ops.map((op) => op.kind === "same"
+        ? { kind: "same", text: oldLines[op.a] }
+        : op.kind === "del"
+            ? { kind: "del", text: oldLines[op.a] }
+            : { kind: "add", text: newLines[op.b] });
+    const changeIdx = raw.map((r, i) => (r.kind === "same" ? -1 : i)).filter((i) => i >= 0);
+    if (changeIdx.length === 0)
+        return empty;
+    const hunks = [];
+    let adds = 0;
+    let dels = 0;
+    let truncated = false;
+    let hunkStart = Math.max(0, changeIdx[0] - DIFF_CONTEXT);
+    let hunkEnd = Math.min(raw.length, changeIdx[0] + DIFF_CONTEXT + 1);
+    const flush = (s, e) => {
+        const slice = raw.slice(s, e);
+        // Old/new line numbers at hunk start.
+        let o = 0;
+        let nn = 0;
+        for (let k = 0; k < s; k++) {
+            if (raw[k].kind !== "add")
+                o += 1;
+            if (raw[k].kind !== "del")
+                nn += 1;
+        }
+        const oldStart = o + 1;
+        const newStart = nn + 1;
+        let oCount = 0;
+        let nCount = 0;
+        // Pair consecutive del/add runs for word highlighting.
+        const lines = [];
+        let k = 0;
+        while (k < slice.length) {
+            const r = slice[k];
+            if (r.kind === "same") {
+                lines.push({ kind: "context", text: r.text });
+                oCount += 1;
+                nCount += 1;
+                k += 1;
+                continue;
+            }
+            const delRun = [];
+            const addRun = [];
+            while (k < slice.length && slice[k].kind === "del") {
+                delRun.push(slice[k].text);
+                k += 1;
+            }
+            while (k < slice.length && slice[k].kind === "add") {
+                addRun.push(slice[k].text);
+                k += 1;
+            }
+            const paired = Math.min(delRun.length, addRun.length);
+            for (let p = 0; p < paired; p++) {
+                const { del, add } = wordRuns(delRun[p], addRun[p]);
+                lines.push({ kind: "del", text: delRun[p], runs: del });
+                lines.push({ kind: "add", text: addRun[p], runs: add });
+            }
+            for (let p = paired; p < delRun.length; p++) {
+                lines.push({ kind: "del", text: delRun[p], runs: flatRuns(delRun[p]) });
+            }
+            for (let p = paired; p < addRun.length; p++) {
+                lines.push({ kind: "add", text: addRun[p], runs: flatRuns(addRun[p]) });
+            }
+            dels += delRun.length;
+            adds += addRun.length;
+            oCount += delRun.length;
+            nCount += addRun.length;
+        }
+        hunks.push({ oldStart, oldLines: oCount, newStart, newLines: nCount, lines });
+    };
+    let changed = 0;
+    for (let c = 1; c < changeIdx.length; c++) {
+        const prev = changeIdx[c - 1];
+        const cur = changeIdx[c];
+        if (cur - prev <= DIFF_CONTEXT * 2 + 1) {
+            hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
+        }
+        else {
+            flush(hunkStart, hunkEnd);
+            changed = hunks.reduce((t, h) => t + h.lines.filter((l) => l.kind !== "context").length, 0);
+            if (changed >= MAX_CHANGED_LINES) {
+                truncated = true;
+                return { hunks, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
+            }
+            hunkStart = Math.max(0, cur - DIFF_CONTEXT);
+            hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
+        }
+    }
+    flush(hunkStart, hunkEnd);
+    changed = hunks.reduce((t, h) => t + h.lines.filter((l) => l.kind !== "context").length, 0);
+    if (changed > MAX_CHANGED_LINES) {
+        // Trim trailing hunks past the budget (keep the head — the user
+        // reviews top-down; the notice names the remainder).
+        let kept = 0;
+        const out = [];
+        for (const h of hunks) {
+            const n = h.lines.filter((l) => l.kind !== "context").length;
+            if (kept + n > MAX_CHANGED_LINES)
+                break;
+            out.push(h);
+            kept += n;
+        }
+        truncated = true;
+        return { hunks: out, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
+    }
+    return { hunks, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
+}
+export function computeSideBySide(oldText, newText) {
+    if (isBinary(newText) || (oldText !== null && isBinary(oldText))) {
+        return { kind: "binary" };
+    }
+    if (newText.length > MAX_FILE_BYTES || (oldText !== null && oldText.length > MAX_FILE_BYTES)) {
+        return { kind: "skipped", reason: "file over 1MB — diff skipped" };
+    }
+    if (oldText !== null && oldText === newText)
+        return { kind: "same" };
+    const oldLines = oldText === null ? [] : splitLines(oldText);
+    const newLines = splitLines(newText);
+    const ops = myersOps(oldLines, newLines);
+    // Numbered raw lines (1-based per side).
+    const raw = [];
+    let o = 0;
+    let nn = 0;
+    for (const op of ops) {
+        if (op.kind === "same") {
+            o += 1;
+            nn += 1;
+            raw.push({ kind: "same", text: oldLines[op.a], oldNo: o, newNo: nn });
+        }
+        else if (op.kind === "del") {
+            o += 1;
+            raw.push({ kind: "del", text: oldLines[op.a], oldNo: o, newNo: null });
+        }
+        else {
+            nn += 1;
+            raw.push({ kind: "add", text: newLines[op.b], oldNo: null, newNo: nn });
+        }
+    }
+    const changeIdx = raw.map((r, i) => (r.kind === "same" ? -1 : i)).filter((i) => i >= 0);
+    if (changeIdx.length === 0)
+        return { kind: "same" };
+    const rows = [];
+    let adds = 0;
+    let dels = 0;
+    let truncated = false;
+    const changedSoFar = () => dels + adds;
+    // Returns false when the change budget is exhausted (stop windowing).
+    const flushSlice = (s, e) => {
+        const slice = raw.slice(s, e);
+        let k = 0;
+        while (k < slice.length) {
+            const r = slice[k];
+            if (r.kind === "same") {
+                rows.push({ kind: "context", oldNo: r.oldNo, newNo: r.newNo, text: r.text });
+                k += 1;
+                continue;
+            }
+            const delRun = [];
+            const addRun = [];
+            while (k < slice.length && slice[k].kind === "del") {
+                delRun.push({ text: slice[k].text, no: slice[k].oldNo });
+                k += 1;
+            }
+            while (k < slice.length && slice[k].kind === "add") {
+                addRun.push({ text: slice[k].text, no: slice[k].newNo });
+                k += 1;
+            }
+            const paired = Math.min(delRun.length, addRun.length);
+            for (let p = 0; p < paired; p++) {
+                const { del, add } = wordRuns(delRun[p].text, addRun[p].text);
+                rows.push({
+                    kind: "change",
+                    oldNo: delRun[p].no,
+                    oldText: delRun[p].text,
+                    oldRuns: del,
+                    newNo: addRun[p].no,
+                    newText: addRun[p].text,
+                    newRuns: add,
+                });
+            }
+            for (let p = paired; p < delRun.length; p++) {
+                rows.push({
+                    kind: "change",
+                    oldNo: delRun[p].no,
+                    oldText: delRun[p].text,
+                    oldRuns: flatRuns(delRun[p].text),
+                    newNo: null,
+                    newText: null,
+                    newRuns: [],
+                });
+            }
+            for (let p = paired; p < addRun.length; p++) {
+                rows.push({
+                    kind: "change",
+                    oldNo: null,
+                    oldText: null,
+                    oldRuns: [],
+                    newNo: addRun[p].no,
+                    newText: addRun[p].text,
+                    newRuns: flatRuns(addRun[p].text),
+                });
+            }
+            dels += delRun.length;
+            adds += addRun.length;
+            if (changedSoFar() >= MAX_CHANGED_LINES) {
+                truncated = true;
+                return false;
+            }
+        }
+        return true;
+    };
+    let hunkStart = Math.max(0, changeIdx[0] - DIFF_CONTEXT);
+    let hunkEnd = Math.min(raw.length, changeIdx[0] + DIFF_CONTEXT + 1);
+    for (let c = 1; c < changeIdx.length; c++) {
+        const prev = changeIdx[c - 1];
+        const cur = changeIdx[c];
+        if (cur - prev <= DIFF_CONTEXT * 2 + 1) {
+            hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
+        }
+        else {
+            if (!flushSlice(hunkStart, hunkEnd)) {
+                return { kind: "diff", rows, adds, dels, truncated, isNewFile: oldText === null };
+            }
+            hunkStart = Math.max(0, cur - DIFF_CONTEXT);
+            hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
+        }
+    }
+    flushSlice(hunkStart, hunkEnd);
+    if (dels + adds > MAX_CHANGED_LINES) {
+        // Single-hunk overflow: the slice already pushed past the budget —
+        // trim trailing rows past 400 changes (keep the head; the notice
+        // names the remainder). Mirrors computeDiff's trailing-hunk trim.
+        let kept = 0;
+        let cut = rows.length;
+        for (let i = 0; i < rows.length; i++) {
+            if (rows[i].kind === "change") {
+                kept += 1;
+                if (kept > MAX_CHANGED_LINES) {
+                    cut = i;
+                    break;
+                }
+            }
+        }
+        rows.length = cut;
+        truncated = true;
+    }
+    return { kind: "diff", rows, adds, dels, truncated, isNewFile: oldText === null };
+}