atom-agent 1.0.0 → 1.1.0

package/dist/tools/read-cache.js

@@ -0,0 +1,160 @@
+// Read-through cache for file reads: repeated `read` calls for the same
+// path+window skip disk I/O when the file hasn't changed. Correctness first:
+//
+// - Key: absolute path + offset + limit (different windows are different keys).
+// - Validation: file mtimeMs + size checked on every hit (one stat, cheap).
+//   A mismatch → miss → re-read + re-store. External edits can never serve
+//   stale bytes beyond a stat race.
+// - Invalidation: write/edit/delete paths call invalidatePath(abs) — the
+//   write/edit executors do this, so read→write→read chains never go stale.
+//   A global version bump (invalidateAll) covers tree-wide mutations.
+// - Scope: successes only (errors never cache — a transient ENOENT must not
+//   poison later reads). Directory listings never cache (readdir is already
+//   cheap and highly mutable).
+// - Bounds: LRU cap (default 100 entries) + TTL (default 30s). Disable with
+//   ATOM_READ_CACHE=0. All best-effort, never throws.
+//
+// Measurable win: explore loops re-read the same files (read after grep,
+// re-read before edit, parallel batches reading shared context). Each hit
+// saves a full readFile + split + 64KB-format pass.
+//
+// Stats (for loop instrumentation + tests): hits, misses, stores, invalidations.
+import * as path from "node:path";
+const DEFAULT_MAX_ENTRIES = 100;
+const DEFAULT_TTL_MS = 30_000;
+const cache = new Map();
+const stats = { hits: 0, misses: 0, stores: 0, invalidations: 0, size: 0 };
+function cacheEnabled() {
+    const raw = process.env.ATOM_READ_CACHE;
+    if (raw === undefined)
+        return true;
+    const v = raw.trim().toLowerCase();
+    return !(v === "0" || v === "false" || v === "no" || v === "off");
+}
+function ttlMs() {
+    const raw = process.env.ATOM_READ_CACHE_TTL_MS;
+    if (raw !== undefined) {
+        const n = Number(raw.trim());
+        if (Number.isFinite(n) && n > 0)
+            return Math.min(Math.floor(n), 300_000);
+    }
+    return DEFAULT_TTL_MS;
+}
+function maxEntries() {
+    const raw = process.env.ATOM_READ_CACHE_MAX;
+    if (raw !== undefined) {
+        const n = Number(raw.trim());
+        if (Number.isFinite(n) && n > 0)
+            return Math.min(Math.floor(n), 1000);
+    }
+    return DEFAULT_MAX_ENTRIES;
+}
+export function readCacheKey(abs, offset, limit) {
+    return `${abs}\n${offset}\n${limit}`;
+}
+export function normalizeReadWindow(offset, limit) {
+    const o = typeof offset === "number" && Number.isFinite(offset) ? Math.max(1, Math.floor(offset)) : 1;
+    const l = typeof limit === "number" && Number.isFinite(limit)
+        ? Math.max(1, Math.floor(limit))
+        : Number.MAX_SAFE_INTEGER;
+    return { offset: o, limit: l };
+}
+// Lookup by absolute path + window. `stat` must be the fresh
+// {mtimeMs, size} of the file (the caller already stats before reading).
+// Returns the cached {result, hash} on hit, null on miss. Never throws.
+export function getCachedRead(abs, offset, limit, stat) {
+    if (!cacheEnabled()) {
+        stats.misses += 1;
+        return null;
+    }
+    const key = readCacheKey(abs, offset, limit);
+    const entry = cache.get(key);
+    if (!entry) {
+        stats.misses += 1;
+        return null;
+    }
+    if (Date.now() - entry.storedAt > ttlMs()) {
+        cache.delete(key);
+        stats.size = cache.size;
+        stats.misses += 1;
+        return null;
+    }
+    if (entry.mtimeMs !== stat.mtimeMs || entry.size !== stat.size) {
+        cache.delete(key);
+        stats.size = cache.size;
+        stats.misses += 1;
+        return null;
+    }
+    // LRU refresh: re-insert so the oldest key stays evictable first.
+    cache.delete(key);
+    cache.set(key, entry);
+    stats.hits += 1;
+    return { result: entry.result, hash: entry.hash };
+}
+// Store a successful file-read result. Never throws; evicts oldest first.
+export function setCachedRead(abs, offset, limit, result, stat, hash) {
+    try {
+        if (!cacheEnabled() || typeof result !== "string")
+            return;
+        const key = readCacheKey(abs, offset, limit);
+        cache.delete(key);
+        while (cache.size >= maxEntries()) {
+            const oldest = cache.keys().next();
+            if (oldest.done)
+                break;
+            cache.delete(oldest.value);
+        }
+        cache.set(key, { result, hash, mtimeMs: stat.mtimeMs, size: stat.size, storedAt: Date.now() });
+        stats.size = cache.size;
+        stats.stores += 1;
+    }
+    catch {
+        // cache failures never break reads
+    }
+}
+// Drop every entry for one absolute path (all windows). Called by
+// write/edit/delete paths. Never throws.
+export function invalidatePath(abs) {
+    try {
+        const prefix = `${abs}\n`;
+        let dropped = 0;
+        for (const key of [...cache.keys()]) {
+            if (key === abs || key.startsWith(prefix)) {
+                cache.delete(key);
+                dropped += 1;
+            }
+        }
+        // Also match callers that pass a relative display path: compare resolved
+        // basenames as a fallback so nothing obviously stale survives.
+        if (dropped === 0 && typeof abs === "string") {
+            const resolved = path.resolve(abs);
+            const resolvedPrefix = `${resolved}\n`;
+            for (const key of [...cache.keys()]) {
+                if (key === resolved || key.startsWith(resolvedPrefix)) {
+                    cache.delete(key);
+                    dropped += 1;
+                }
+            }
+        }
+        if (dropped > 0)
+            stats.invalidations += dropped;
+        stats.size = cache.size;
+    }
+    catch {
+        // never throw across the tool boundary
+    }
+}
+export function clearReadCache() {
+    cache.clear();
+    stats.size = 0;
+}
+export function getReadCacheStats() {
+    return { ...stats, size: cache.size };
+}
+export function resetReadCacheStats() {
+    stats.hits = 0;
+    stats.misses = 0;
+    stats.stores = 0;
+    stats.invalidations = 0;
+    stats.size = cache.size;
+}

package/dist/tools/registry.js

@@ -375,6 +375,85 @@ export function describeToolCall(name, args) {
             return `⚙ ${name}`;
     }
 }
+// Shared byte cap for approve-time file reads (preview + BEFORE capture).
+export const APPROVAL_PREVIEW_MAX_BYTES = 1_000_000;
+// Extension → highlight family (see ui/highlight.ts). Conservative: only
+// extensions we are confident about; everything else stays null (plain).
+const PREVIEW_LANG_BY_EXT = {
+    ts: "c",
+    tsx: "c",
+    mts: "c",
+    cts: "c",
+    js: "c",
+    jsx: "c",
+    mjs: "c",
+    cjs: "c",
+    go: "c",
+    rs: "c",
+    java: "c",
+    c: "c",
+    h: "c",
+    hh: "c",
+    cc: "c",
+    cpp: "c",
+    hpp: "c",
+    cs: "c",
+    swift: "c",
+    kt: "c",
+    kts: "c",
+    php: "c",
+    py: "py",
+    pyi: "py",
+    rb: "py",
+    sh: "sh",
+    bash: "sh",
+    zsh: "sh",
+    json: "data",
+    jsonc: "data",
+    yaml: "data",
+    yml: "data",
+    toml: "data",
+};
+export function previewLangFromPath(p) {
+    const base = p.split(/[\\/]/).pop() ?? p;
+    const dot = base.lastIndexOf(".");
+    if (dot <= 0 || dot === base.length - 1)
+        return null;
+    return PREVIEW_LANG_BY_EXT[base.slice(dot + 1).toLowerCase()] ?? null;
+}
+export function previewDiffForApproval(name, args, cwd = process.cwd()) {
+    try {
+        if (name === "edit") {
+            const a = args;
+            if (typeof a.oldString !== "string" || typeof a.newString !== "string")
+                return null;
+            const p = typeof a.path === "string" ? a.path : null;
+            return { oldText: a.oldString, newText: a.newString, lang: p ? previewLangFromPath(p) : null, path: p };
+        }
+        if (name === "write") {
+            const a = args;
+            if (typeof a.content !== "string" || typeof a.path !== "string" || a.path.length === 0) {
+                return null;
+            }
+            let oldText = null;
+            try {
+                const abs = path.resolve(cwd, a.path);
+                const st = fs.statSync(abs);
+                if (st.isFile() && st.size <= APPROVAL_PREVIEW_MAX_BYTES) {
+                    oldText = fs.readFileSync(abs, "utf8");
+                }
+            }
+            catch {
+                oldText = null;
+            }
+            return { oldText, newText: a.content, lang: previewLangFromPath(a.path), path: a.path };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 // OpenAI-style function schemas sent as `tools` on the chat POST.
 export const TOOL_DEFINITIONS = [
     {

package/dist/tools/search.js

@@ -2,7 +2,8 @@
 // Read-only over the repo; node_modules/.git skipped by the walker.
 import { promises as fsp } from "node:fs";
 import * as path from "node:path";
-import { err, GLOB_MATCH_CAP, GREP_MATCH_CAP, invalidCall, resolveSandbox, SKIP_DIRS } from "./shared.js";
+import { listFiles } from "./dir-cache.js";
+import { err, GLOB_MATCH_CAP, GREP_MATCH_CAP, invalidCall, resolveSandbox } from "./shared.js";
 // Minimal glob matcher: supports **, **/, *, ?. Used for grep `include`
 // and the glob tool. Patterns without a slash match the basename.
 function globToRegExp(glob) {
@@ -46,25 +47,33 @@ function matchesGlob(pattern, relPosix) {
     }
     return globToRegExp(norm).test(relPosix);
 }
-async function walkFiles(absDir, cwd, out) {
-    const entries = await fsp.readdir(absDir, { withFileTypes: true });
-    for (const e of entries) {
-        if (SKIP_DIRS.has(e.name))
-            continue;
-        const full = path.join(absDir, e.name);
-        if (e.isDirectory()) {
-            await walkFiles(full, cwd, out);
-        }
-        else if (e.isFile()) {
-            out.push(path.relative(cwd, full).split(path.sep).join("/"));
-        }
-    }
-}
 export const GREP_OUTPUT_MODES = new Set([
     "content",
     "files_with_matches",
     "count",
 ]);
+// File-read fan-out for scans: bounded parallelism (32 in flight) over an
+// ordered list, results in input order. Disk I/O overlaps instead of
+// serializing one open/read/close at a time; the regex pass stays sequential
+// afterwards so outputs and first-failure errors keep exact alpha order.
+// 32 concurrent opens is far below EMFILE on every supported platform.
+const SCAN_CONCURRENCY = 32;
+async function mapLimit(items, limit, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    const workers = new Array(Math.min(Math.max(limit, 1), Math.max(items.length, 1)))
+        .fill(0)
+        .map(async () => {
+        for (;;) {
+            const i = next++;
+            if (i >= items.length)
+                return;
+            out[i] = await fn(items[i], i);
+        }
+    });
+    await Promise.all(workers);
+    return out;
+}
 // Best-effort mtime (ms) for recency sorting; 0 when the file cannot be
 // stat'ed (keeps such entries last instead of failing the search).
 async function mtimeMs(abs) {
@@ -110,37 +119,60 @@ export async function grepTool(args, cwd = process.cwd()) {
         }
         if (!st.isDirectory())
             return err(`not a directory: ${dir}`);
-        const files = [];
-        await walkFiles(r.abs, cwd, files);
+        const files = await listFiles(r.abs, cwd);
         const include = typeof args.include === "string" && args.include.length > 0 ? args.include : null;
-        // Per-file match counts in alpha order (single scan for all modes).
-        // Counts are matching LINES per file (ripgrep --count semantics).
-        const counts = [];
-        for (const rel of files.sort()) {
+        // Single scan for all modes: ONE read per file (the old code read every
+        // file twice — counts pass, then content pass). Counts are matching LINES
+        // per file (ripgrep --count semantics); content hits accumulate inline in
+        // the same alpha order the two-pass scan produced, so outputs are
+        // byte-identical with half the I/O.
+        const collectHits = mode === "content";
+        const sorted = files.sort();
+        // Bulk read (bounded parallelism), then regex sequentially: I/O overlaps
+        // while outputs and first-failure errors keep exact alpha order.
+        const bodies = await mapLimit(sorted, SCAN_CONCURRENCY, async (rel) => {
             if (include && !matchesGlob(include, rel))
-                continue;
-            let text;
+                return null;
             try {
-                text = await fsp.readFile(path.resolve(cwd, rel), "utf8");
+                const text = await fsp.readFile(path.resolve(cwd, rel), "utf8");
+                if (text.includes("\0"))
+                    return null; // binary — skip
+                return { rel, text };
             }
             catch {
-                continue; // unreadable/binary — skip
+                return null; // unreadable — skip
             }
-            if (text.includes("\0"))
-                continue; // binary — skip
+        });
+        const counts = [];
+        const hits = [];
+        let hitsCapped = false;
+        for (const body of bodies) {
+            if (body === null)
+                continue;
+            if (collectHits && hitsCapped)
+                break;
+            const { rel, text } = body;
             const lines = text.split("\n");
             let n = 0;
             for (let i = 0; i < lines.length; i++) {
+                let matched;
                 try {
-                    if (!re.test(lines[i]))
-                        continue;
-                    n += 1;
+                    matched = re.test(lines[i]);
                 }
                 catch {
                     return err(`regex failed on input: ${args.pattern}`);
                 }
                 // Reset lastIndex in case the pattern is global/sticky.
                 re.lastIndex = 0;
+                if (!matched)
+                    continue;
+                n += 1;
+                if (collectHits && !hitsCapped) {
+                    const line = lines[i];
+                    hits.push(`${rel}:${i + 1}: ${line.length > 200 ? line.slice(0, 200) + "…" : line}`);
+                    if (hits.length >= GREP_MATCH_CAP)
+                        hitsCapped = true;
+                }
             }
             if (n > 0)
                 counts.push({ rel, n });
@@ -165,34 +197,9 @@ export async function grepTool(args, cwd = process.cwd()) {
                 out += "\n[truncated: more than 100 matching files]";
             return out;
         }
-        const hits = [];
-        for (const c of counts) {
-            let text;
-            try {
-                text = await fsp.readFile(path.resolve(cwd, c.rel), "utf8");
-            }
-            catch {
-                continue; // vanished mid-search — skip
-            }
-            const lines = text.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-                let line;
-                try {
-                    if (!re.test(lines[i]))
-                        continue;
-                    line = lines[i];
-                }
-                catch {
-                    return err(`regex failed on input: ${args.pattern}`);
-                }
-                // Reset lastIndex in case the pattern is global/sticky.
-                re.lastIndex = 0;
-                hits.push(`${c.rel}:${i + 1}: ${line.length > 200 ? line.slice(0, 200) + "…" : line}`);
-                if (hits.length >= GREP_MATCH_CAP) {
-                    return hits.join("\n") + "\n[truncated: more than 100 matches]";
-                }
-            }
-        }
+        // Content hits accumulated inline above (same order, same cap).
+        if (hitsCapped)
+            return hits.join("\n") + "\n[truncated: more than 100 matches]";
         return hits.length > 0 ? hits.join("\n") : "No matches.";
     }
     catch (e) {
@@ -219,8 +226,7 @@ export async function globTool(args, cwd = process.cwd()) {
         }
         if (!st.isDirectory())
             return err(`not a directory: ${dir}`);
-        const files = [];
-        await walkFiles(r.abs, cwd, files);
+        const files = await listFiles(r.abs, cwd);
         const matched = files.filter((rel) => matchesGlob(args.pattern, rel));
         const withTime = await Promise.all(matched.map(async (rel) => ({ rel, t: await mtimeMs(path.resolve(cwd, rel)) })));
         withTime.sort((a, b) => b.t - a.t || (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0));

package/dist/tools/shell.js

@@ -9,6 +9,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { scrubSecrets } from "../policy.js";
 import { PROVIDERS } from "../providers.js";
+import { clearDirListingCache } from "./dir-cache.js";
 import { appendOverflow } from "./overflow.js";
 import { err, OUTPUT_CAP } from "./shared.js";
 // ---- Background bash tasks (Claude-Code-style run_in_background) ----
@@ -120,6 +121,16 @@ async function startBackgroundBash(command, cwd) {
             rec.exitCode = typeof code === "number" ? code : 1;
         });
         child.unref();
+        // A spawned command can touch anything (files, trees, checkouts): the
+        // directory-listing cache cannot know what changed, so drop it all. Cheap
+        // (next search rescans once) and exactly correct for tool-driven flows;
+        // only out-of-process edits stay TTL-bound.
+        try {
+            clearDirListingCache();
+        }
+        catch {
+            // never break the tool
+        }
         return JSON.stringify({ backgroundTaskId: id, status: "running", hint: "use bash_output to poll" });
     }
     catch (e) {
@@ -213,6 +224,14 @@ export function bashTool(args, cwd = process.cwd()) {
     const timeoutMs = Math.min(Math.max(Math.floor(args.timeoutMs ?? 60000), 1), 120000);
     return new Promise((resolve) => {
         exec(args.command, { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 16 * 1024 * 1024 }, (error, stdout, stderr) => {
+            // The command ran (whatever its exit): it may have mutated the tree,
+            // so the listing cache is dropped (see background path above).
+            try {
+                clearDirListingCache();
+            }
+            catch {
+                // never break the tool
+            }
             try {
                 const e = error;
                 const exitCode = e ? (typeof e.code === "number" ? e.code : 1) : 0;

package/dist/tools/todo.js

@@ -20,7 +20,7 @@ export function clearTodos() {
 function renderTodos(items) {
     if (items.length === 0)
         return "Todo list is empty.";
-    const mark = (s) => s === "completed" ? "✅" : s === "in_progress" ? "🔧" : "❌";
+    const mark = (s) => s === "completed" ? "✅" : s === "in_progress" ? "🔧" : "○";
     return (`Todo list (${items.length}):\n` +
         items
             .map((t, i) => `${i + 1}. ${mark(t.status)} [${t.status}] ${t.content}${t.priority ? ` (${t.priority})` : ""}`)

package/dist/tools.js

@@ -10,7 +10,9 @@
 // `"../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/search.js";
 export * from "./tools/shared.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,112 @@
+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.
+export 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);