agent-sh 0.1.0

package/dist/utils/diff-renderer.js

@@ -0,0 +1,506 @@
+/**
+ * Diff renderer with width-adaptive presentation modes and inline highlighting.
+ *
+ * Returns string[] (one per terminal line) — never writes to stdout.
+ * Supports unified, split (side-by-side), and summary modes.
+ * Uses token-level LCS for word-level inline diff highlighting.
+ */
+import { highlight } from "cli-highlight";
+import { visibleLen } from "./ansi.js";
+import { palette as p } from "./palette.js";
+// ── Constants ────────────────────────────────────────────────────
+const SPLIT_MIN_WIDTH = 120;
+const UNIFIED_MIN_WIDTH = 40;
+// ── Syntax highlighting ──────────────────────────────────────────
+const EXT_TO_LANG = {
+    ".ts": "typescript", ".tsx": "typescript", ".js": "javascript", ".jsx": "javascript",
+    ".py": "python", ".rb": "ruby", ".rs": "rust", ".go": "go", ".java": "java",
+    ".c": "c", ".h": "c", ".cpp": "cpp", ".hpp": "cpp", ".cs": "csharp",
+    ".swift": "swift", ".kt": "kotlin", ".scala": "scala",
+    ".sh": "bash", ".bash": "bash", ".zsh": "bash", ".fish": "bash",
+    ".json": "json", ".yaml": "yaml", ".yml": "yaml", ".toml": "ini",
+    ".xml": "xml", ".html": "html", ".htm": "html", ".css": "css", ".scss": "scss",
+    ".sql": "sql", ".md": "markdown", ".lua": "lua", ".php": "php",
+    ".ex": "elixir", ".exs": "elixir", ".erl": "erlang",
+    ".hs": "haskell", ".ml": "ocaml", ".clj": "clojure",
+    ".vim": "vim", ".dockerfile": "dockerfile",
+};
+function detectLanguage(filePath) {
+    if (!filePath)
+        return undefined;
+    const dot = filePath.lastIndexOf(".");
+    if (dot === -1) {
+        // Handle extensionless files like Dockerfile, Makefile
+        const base = filePath.split("/").pop()?.toLowerCase();
+        if (base === "dockerfile")
+            return "dockerfile";
+        if (base === "makefile")
+            return "makefile";
+        return undefined;
+    }
+    return EXT_TO_LANG[filePath.slice(dot).toLowerCase()];
+}
+/**
+ * Syntax-highlight a single line of code.
+ * Returns the original text if highlighting fails or no language detected.
+ */
+function highlightLine(text, language) {
+    if (!language || text.trim() === "")
+        return text;
+    try {
+        // cli-highlight adds a trailing newline; strip it
+        return highlight(text, { language }).replace(/\n$/, "");
+    }
+    catch {
+        return text;
+    }
+}
+function tokenize(line) {
+    const tokens = [];
+    const re = /(\s+)|([A-Za-z0-9_]+)|([^\s\w])/g;
+    let m;
+    while ((m = re.exec(line)) !== null) {
+        if (m[1])
+            tokens.push({ text: m[1], kind: "space" });
+        else if (m[2])
+            tokens.push({ text: m[2], kind: "word" });
+        else if (m[3])
+            tokens.push({ text: m[3], kind: "punct" });
+    }
+    return tokens;
+}
+function tokenLcs(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] =
+                a[i - 1].text === b[j - 1].text
+                    ? dp[i - 1][j - 1] + 1
+                    : Math.max(dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+    // Backtrack to mark matched tokens
+    const oldMatch = new Array(m).fill(false);
+    const newMatch = new Array(n).fill(false);
+    let i = m;
+    let j = n;
+    while (i > 0 && j > 0) {
+        if (a[i - 1].text === b[j - 1].text) {
+            oldMatch[i - 1] = true;
+            newMatch[j - 1] = true;
+            i--;
+            j--;
+        }
+        else if (dp[i - 1][j] >= dp[i][j - 1]) {
+            i--;
+        }
+        else {
+            j--;
+        }
+    }
+    return { oldMatch, newMatch };
+}
+/**
+ * Rewrite full ANSI resets (\x1b[0m) to foreground-only resets,
+ * preserving the given background color across the line.
+ */
+function preserveBg(text, bg) {
+    return text.replace(/\x1b\[0m/g, `\x1b[39m${bg}`);
+}
+/**
+ * Pad a rendered line with spaces to fill the given visible width,
+ * ensuring background color spans the full column.
+ */
+function padToWidth(text, targetWidth) {
+    const vis = visibleLen(text);
+    if (vis >= targetWidth)
+        return text;
+    return text + " ".repeat(targetWidth - vis);
+}
+function highlightInlineChanges(oldLine, newLine, oldPalette, newPalette, useTrueColor, language) {
+    if (!useTrueColor) {
+        // Still apply syntax highlighting even without true-color backgrounds
+        if (language) {
+            return {
+                old: highlightLine(oldLine, language),
+                new: highlightLine(newLine, language),
+            };
+        }
+        return { old: oldLine, new: newLine };
+    }
+    const oldTokens = tokenize(oldLine);
+    const newTokens = tokenize(newLine);
+    // Skip if either side is trivially small
+    if (oldTokens.length === 0 || newTokens.length === 0) {
+        return {
+            old: language ? highlightLine(oldLine, language) : oldLine,
+            new: language ? highlightLine(newLine, language) : newLine,
+        };
+    }
+    // Safety guard: skip if LCS matrix would be too large
+    if (oldTokens.length * newTokens.length > 50000) {
+        return {
+            old: language ? highlightLine(oldLine, language) : oldLine,
+            new: language ? highlightLine(newLine, language) : newLine,
+        };
+    }
+    const { oldMatch, newMatch } = tokenLcs(oldTokens, newTokens);
+    const buildHighlighted = (tokens, matched, palette) => {
+        let result = "";
+        for (let i = 0; i < tokens.length; i++) {
+            if (matched[i]) {
+                // Matched (unchanged) tokens: syntax highlight + row background
+                const text = language ? highlightLine(tokens[i].text, language) : tokens[i].text;
+                result += palette.rowBg + preserveBg(text, palette.rowBg);
+            }
+            else {
+                // Changed tokens: emphasis background, no syntax highlighting (emphasis stands out)
+                result += palette.emphBg + p.bold + tokens[i].text + p.reset;
+            }
+        }
+        return result;
+    };
+    return {
+        old: buildHighlighted(oldTokens, oldMatch, oldPalette),
+        new: buildHighlighted(newTokens, newMatch, newPalette),
+    };
+}
+/**
+ * Scan a hunk for adjacent removed/added runs and pair them 1:1.
+ * Returns a set of line indices that are part of a change pair.
+ */
+function findChangePairs(hunk) {
+    const pairs = new Map();
+    const lines = hunk.lines;
+    let i = 0;
+    while (i < lines.length) {
+        // Find a run of removed lines
+        const removedStart = i;
+        while (i < lines.length && lines[i].type === "removed")
+            i++;
+        const removedEnd = i;
+        // Find a run of added lines immediately after
+        const addedStart = i;
+        while (i < lines.length && lines[i].type === "added")
+            i++;
+        const addedEnd = i;
+        // Pair them 1:1
+        const removedCount = removedEnd - removedStart;
+        const addedCount = addedEnd - addedStart;
+        const pairCount = Math.min(removedCount, addedCount);
+        for (let k = 0; k < pairCount; k++) {
+            const pair = {
+                removed: lines[removedStart + k],
+                added: lines[addedStart + k],
+                removedIdx: removedStart + k,
+                addedIdx: addedStart + k,
+            };
+            pairs.set(removedStart + k, pair);
+            pairs.set(addedStart + k, pair);
+        }
+        // If no removed/added run was found, advance past context lines
+        if (removedCount === 0 && addedCount === 0) {
+            i++;
+        }
+    }
+    return pairs;
+}
+// ── Header ───────────────────────────────────────────────────────
+function buildHeader(diff, filePath) {
+    const path = filePath ?? "";
+    if (diff.isNewFile) {
+        return `${p.bold}new: ${path}${p.reset}  ${p.dim}(+${diff.added} lines)${p.reset}`;
+    }
+    return `${p.bold}${path}${p.reset}  ${p.dim}(+${diff.added} / -${diff.removed})${p.reset}`;
+}
+// ── Summary mode ─────────────────────────────────────────────────
+function renderSummary(diff) {
+    if (diff.isIdentical)
+        return [`${p.dim}(no changes)${p.reset}`];
+    if (diff.isNewFile)
+        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;
+    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) {
+            const n = line.oldNo ?? line.newNo ?? 0;
+            if (n > maxNo)
+                maxNo = n;
+        }
+    }
+    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}`);
+        }
+        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") {
+                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;
+            }
+            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) {
+                    const rowContent = `${p.errorBg}${p.error}- ${no} │ ${preserveBg(removedText, p.errorBg)}${p.reset}`;
+                    output.push(padToWidth(rowContent, 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}`);
+                    }
+                }
+                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) {
+                    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}`);
+                }
+            }
+        }
+    }
+    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;
+    const totalWidth = opts.width;
+    // 3 chars for " │ " separator
+    const colWidth = 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) {
+            const n = line.oldNo ?? line.newNo ?? 0;
+            if (n > maxNo)
+                maxNo = n;
+        }
+    }
+    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);
+                }
+            }
+            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.success}${rightNo} │ ${rightText}${p.reset}`, colWidth);
+                }
+            }
+            else {
+                rightCol = padToWidth(`${p.dim}${rightNo} │${p.reset} ${rightText}`, colWidth);
+            }
+            output.push(`${leftCol} ${p.dim}│${p.reset} ${rightCol}`);
+        }
+    }
+    return output;
+}
+function buildSplitRows(hunk) {
+    const rows = [];
+    const lines = hunk.lines;
+    let i = 0;
+    while (i < lines.length) {
+        if (lines[i].type === "context") {
+            rows.push({ left: lines[i], right: lines[i] });
+            i++;
+            continue;
+        }
+        // Collect a run of removed lines
+        const removed = [];
+        while (i < lines.length && lines[i].type === "removed") {
+            removed.push(lines[i]);
+            i++;
+        }
+        // Collect a run of added lines
+        const added = [];
+        while (i < lines.length && lines[i].type === "added") {
+            added.push(lines[i]);
+            i++;
+        }
+        // Pair them side by side
+        const maxLen = Math.max(removed.length, added.length);
+        for (let k = 0; k < maxLen; k++) {
+            rows.push({
+                left: k < removed.length ? removed[k] : null,
+                right: k < added.length ? added[k] : null,
+            });
+        }
+    }
+    return rows;
+}
+// ── Utilities ────────────────────────────────────────────────────
+/**
+ * Truncate text to fit within maxWidth visible characters.
+ * ANSI-aware: measures visible length and preserves escape codes.
+ */
+function truncateText(text, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    if (visibleLen(text) <= maxWidth)
+        return text;
+    if (maxWidth <= 1)
+        return "…";
+    // Walk through the string, tracking visible characters
+    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) {
+                i = end + 1;
+                continue;
+            }
+        }
+        visible++;
+        i++;
+    }
+    return text.slice(0, i) + p.reset + "…";
+}
+// ── Public API ───────────────────────────────────────────────────
+/** Select display mode based on available terminal width. */
+export function selectMode(width) {
+    if (width >= SPLIT_MIN_WIDTH)
+        return "split";
+    if (width >= UNIFIED_MIN_WIDTH)
+        return "unified";
+    return "summary";
+}
+/** Render a diff result as an array of ANSI-formatted terminal lines. */
+export function renderDiff(diff, opts) {
+    if (diff.isIdentical)
+        return [`${p.dim}(no changes)${p.reset}`];
+    const mode = opts.mode ?? selectMode(opts.width);
+    const maxLines = opts.maxLines ?? 50;
+    const header = buildHeader(diff, opts.filePath);
+    if (mode === "summary") {
+        return [header, ...renderSummary(diff)];
+    }
+    let bodyLines;
+    switch (mode) {
+        case "split":
+            bodyLines = renderSplit(diff, opts);
+            break;
+        case "unified":
+            bodyLines = renderUnified(diff, opts);
+            break;
+    }
+    // Truncation
+    if (bodyLines.length > maxLines) {
+        const overflow = bodyLines.length - maxLines;
+        bodyLines = bodyLines.slice(0, maxLines);
+        bodyLines.push(`${p.dim}… ${overflow} more lines${p.reset}`);
+    }
+    return [header, ...bodyLines];
+}

package/dist/utils/diff.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Lightweight LCS-based line diff for file modification previews.
+ */
+export interface DiffLine {
+    type: "context" | "added" | "removed";
+    oldNo: number | null;
+    newNo: number | null;
+    text: string;
+}
+export interface DiffHunk {
+    lines: DiffLine[];
+}
+export interface DiffResult {
+    hunks: DiffHunk[];
+    added: number;
+    removed: number;
+    isIdentical: boolean;
+    isNewFile: boolean;
+}
+/**
+ * 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;

package/dist/utils/diff.js

@@ -0,0 +1,122 @@
+/**
+ * Lightweight LCS-based line diff for file modification previews.
+ */
+/**
+ * Compute a line-level diff between old and new file content.
+ * Returns grouped hunks with 3 lines of context around each change.
+ */
+export function computeDiff(oldText, newText) {
+    // New file — everything is an addition
+    if (oldText === null) {
+        const lines = newText.split("\n");
+        return {
+            hunks: [
+                {
+                    lines: lines.map((text, i) => ({
+                        type: "added",
+                        oldNo: null,
+                        newNo: i + 1,
+                        text,
+                    })),
+                },
+            ],
+            added: lines.length,
+            removed: 0,
+            isIdentical: false,
+            isNewFile: true,
+        };
+    }
+    // Identical — nothing to show
+    if (oldText === newText) {
+        return {
+            hunks: [],
+            added: 0,
+            removed: 0,
+            isIdentical: true,
+            isNewFile: false,
+        };
+    }
+    // Build LCS table and backtrack to produce diff lines
+    const a = oldText.split("\n");
+    const b = newText.split("\n");
+    const dp = buildLcs(a, b);
+    const raw = backtrack(dp, a, b);
+    let added = 0;
+    let removed = 0;
+    for (const l of raw) {
+        if (l.type === "added")
+            added++;
+        else if (l.type === "removed")
+            removed++;
+    }
+    return {
+        hunks: groupHunks(raw, 3),
+        added,
+        removed,
+        isIdentical: false,
+        isNewFile: false,
+    };
+}
+function buildLcs(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++)
+        for (let j = 1; j <= n; j++)
+            dp[i][j] =
+                a[i - 1] === b[j - 1]
+                    ? dp[i - 1][j - 1] + 1
+                    : Math.max(dp[i - 1][j], dp[i][j - 1]);
+    return dp;
+}
+function backtrack(dp, a, b) {
+    const result = [];
+    let i = a.length;
+    let j = b.length;
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+            result.unshift({ type: "context", oldNo: i, newNo: j, text: a[i - 1] });
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            result.unshift({ type: "added", oldNo: null, newNo: j, text: b[j - 1] });
+            j--;
+        }
+        else {
+            result.unshift({
+                type: "removed",
+                oldNo: i,
+                newNo: null,
+                text: a[i - 1],
+            });
+            i--;
+        }
+    }
+    return result;
+}
+function groupHunks(lines, ctx) {
+    const changeIdx = [];
+    for (let i = 0; i < lines.length; i++)
+        if (lines[i].type !== "context")
+            changeIdx.push(i);
+    if (changeIdx.length === 0)
+        return [];
+    const hunks = [];
+    let start = Math.max(0, changeIdx[0] - ctx);
+    let end = Math.min(lines.length - 1, changeIdx[0] + ctx);
+    for (let k = 1; k < changeIdx.length; k++) {
+        const ns = Math.max(0, changeIdx[k] - ctx);
+        const ne = Math.min(lines.length - 1, changeIdx[k] + ctx);
+        if (ns <= end + 1) {
+            end = ne;
+        }
+        else {
+            hunks.push({ lines: lines.slice(start, end + 1) });
+            start = ns;
+            end = ne;
+        }
+    }
+    hunks.push({ lines: lines.slice(start, end + 1) });
+    return hunks;
+}

package/dist/utils/file-watcher.d.ts

@@ -0,0 +1,31 @@
+export interface FileChange {
+    path: string;
+    relPath: string;
+    before: string;
+    after: string;
+}
+/**
+ * Snapshots the working directory before an agent prompt so that
+ * file modifications made by **any** method (ACP writeTextFile,
+ * the agent's own edit tools, shell commands, etc.) can be detected
+ * and shown as an interactive diff preview.
+ */
+export declare class FileWatcher {
+    private cwd;
+    private baseline;
+    constructor(cwd: string);
+    /**
+     * Recursively snapshot all text files in the working directory.
+     * Skips common non-source directories, binary files, and files
+     * exceeding MAX_FILE_SIZE.  Capped at MAX_FILES entries.
+     */
+    snapshot(): Promise<void>;
+    /** Update baseline after a write is approved (avoids double-reporting). */
+    approve(absPath: string, content: string): void;
+    /** Detect all tracked files whose on-disk content differs from baseline. */
+    detectChanges(): Promise<FileChange[]>;
+    /** Revert a file to its baseline content. */
+    revert(absPath: string): Promise<void>;
+    /** Clear all tracking state. */
+    reset(): void;
+}