@heyhuynhgiabuu/pi-diff 0.2.2 → 0.3.0

package/dist/index.js

@@ -0,0 +1,1738 @@
+"use strict";
+/**
+ * pi-diff — Shiki-powered terminal diff renderer for pi.
+ *
+ * @module pi-diff
+ * @see https://github.com/buddingnewinsights/pi-diff
+ *
+ * Architecture (like OpenTUI / delta):
+ *   1. Syntax-highlight full code blocks via Shiki → ANSI (fg-only codes)
+ *   2. Layer diff background colors underneath (composites at cell level)
+ *   3. For word-level changes, inject brighter bg at changed char positions
+ *   4. Result: syntax fg + diff bg + word emphasis — all three visible together
+ *
+ * Views:
+ *   • Split (side-by-side) — edit tool, auto-falls back to unified on narrow terminals
+ *   • Unified (stacked)    — write tool overwrites
+ *
+ * Performance:
+ *   • Singleton Shiki highlighter (managed by @shikijs/cli)
+ *   • LRU memo cache per highlighted block
+ *   • Large-diff fallback (skip highlighting, still show diff)
+ *   • Async rendering with invalidate() for non-blocking preview
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing = void 0;
+exports.default = diffRendererExtension;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const cli_1 = require("@shikijs/cli");
+const Diff = __importStar(require("diff"));
+const diff_js_1 = require("./core/diff.js");
+const command_js_1 = require("./review/command.js");
+const export_js_1 = require("./review/export.js");
+const git_js_1 = require("./review/git.js");
+const hunk_preview_js_1 = require("./review/hunk-preview.js");
+const interactive_js_1 = require("./review/interactive.js");
+const DIFF_PRESETS = {
+    default: {
+        name: "default",
+        description: "Original pi-diff colors — tuned for dark theme bases (~#1e1e2e)",
+        bgAdd: "#162620",
+        bgDel: "#2d1919",
+        bgAddHighlight: "#234b32",
+        bgDelHighlight: "#502323",
+        bgGutterAdd: "#12201a",
+        bgGutterDel: "#261616",
+        bgEmpty: "#121212",
+        fgDim: "#505050",
+        fgLnum: "#646464",
+        fgRule: "#323232",
+        fgStripe: "#282828",
+        fgSafeMuted: "#8b949e",
+    },
+    midnight: {
+        name: "midnight",
+        description: "Subtle tints for pure black (#000000) terminal backgrounds",
+        bgAdd: "#0d1a12",
+        bgDel: "#1a0d0d",
+        bgAddHighlight: "#1a3825",
+        bgDelHighlight: "#381a1a",
+        bgGutterAdd: "#091208",
+        bgGutterDel: "#120908",
+        bgEmpty: "#080808",
+        fgDim: "#404040",
+        fgLnum: "#505050",
+        fgRule: "#282828",
+        fgStripe: "#1e1e1e",
+        fgSafeMuted: "#8b949e",
+    },
+    subtle: {
+        name: "subtle",
+        description: "Minimal backgrounds — barely-there tints for a clean look",
+        bgAdd: "#081008",
+        bgDel: "#100808",
+        bgAddHighlight: "#122818",
+        bgDelHighlight: "#281212",
+        bgGutterAdd: "#060c06",
+        bgGutterDel: "#0c0606",
+        bgEmpty: "#060606",
+        fgDim: "#383838",
+        fgLnum: "#484848",
+        fgRule: "#242424",
+        fgStripe: "#181818",
+        fgSafeMuted: "#8b949e",
+    },
+    neon: {
+        name: "neon",
+        description: "Higher contrast backgrounds for better visibility",
+        bgAdd: "#1a3320",
+        bgDel: "#331a16",
+        bgAddHighlight: "#2d5c3a",
+        bgDelHighlight: "#5c2d2d",
+        bgGutterAdd: "#142818",
+        bgGutterDel: "#28120e",
+        bgEmpty: "#141414",
+        fgDim: "#606060",
+        fgLnum: "#787878",
+        fgRule: "#404040",
+        fgStripe: "#303030",
+        fgSafeMuted: "#9da5ae",
+    },
+};
+/** Parse 24-bit ANSI color code → RGB. Works for both fg and bg escapes. */
+function parseAnsiRgb(ansi) {
+    const esc = "\u001b";
+    const m = ansi.match(new RegExp(`${esc}\\[(?:38|48);2;(\\d+);(\\d+);(\\d+)m`));
+    return m ? { r: +m[1], g: +m[2], b: +m[3] } : null;
+}
+/** Convert "#RRGGBB" hex → ANSI 24-bit background escape. */
+function hexToBgAnsi(hex) {
+    if (!hex || !/^#[0-9a-fA-F]{6}$/.test(hex))
+        return "";
+    const r = Number.parseInt(hex.slice(1, 3), 16);
+    const g = Number.parseInt(hex.slice(3, 5), 16);
+    const b = Number.parseInt(hex.slice(5, 7), 16);
+    return `\x1b[48;2;${r};${g};${b}m`;
+}
+/** Convert "#RRGGBB" hex → ANSI 24-bit foreground escape. */
+function hexToFgAnsi(hex) {
+    if (!hex || !/^#[0-9a-fA-F]{6}$/.test(hex))
+        return "";
+    const r = Number.parseInt(hex.slice(1, 3), 16);
+    const g = Number.parseInt(hex.slice(3, 5), 16);
+    const b = Number.parseInt(hex.slice(5, 7), 16);
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+/** Derive a muted background ANSI code from a foreground ANSI code.
+ *  Scales the fg RGB by `intensity` (0.0–1.0) to produce a subtle tint. */
+function deriveBgFromFg(fgAnsi, intensity) {
+    const rgb = parseAnsiRgb(fgAnsi);
+    if (!rgb)
+        return "";
+    const r = Math.round(rgb.r * intensity);
+    const g = Math.round(rgb.g * intensity);
+    const b = Math.round(rgb.b * intensity);
+    return `\x1b[48;2;${r};${g};${b}m`;
+}
+/** Mix an accent color into a base color at the given intensity (0.0–1.0).
+ *  Returns an ANSI 24-bit background escape. Used to derive diff backgrounds
+ *  that blend with the tool box background (toolSuccessBg). */
+function mixBg(base, accent, intensity) {
+    const r = Math.round(base.r + (accent.r - base.r) * intensity);
+    const g = Math.round(base.g + (accent.g - base.g) * intensity);
+    const b = Math.round(base.b + (accent.b - base.b) * intensity);
+    return `\x1b[48;2;${r};${g};${b}m`;
+}
+/** Whether auto-derive from theme is still pending (runs lazily on first render). */
+let _autoDerivePending = true;
+/** Whether user set explicit bg config (via preset or per-color overrides). */
+let _hasExplicitBgConfig = false;
+/** Auto-derive all diff background colors from the pi theme's fg diff colors.
+ *  Reads toolSuccessBg as the add/context base and toolErrorBg as the delete base,
+ *  then mixes accent colors into each. Falls back to black (0,0,0) when a theme
+ *  background is unavailable; toolErrorBg falls back to toolSuccessBg. */
+function autoDeriveBgFromTheme(theme) {
+    if (!theme?.getFgAnsi)
+        return;
+    try {
+        const fgAdd = theme.getFgAnsi("toolDiffAdded");
+        const fgDel = theme.getFgAnsi("toolDiffRemoved");
+        const addRgb = parseAnsiRgb(fgAdd);
+        const delRgb = parseAnsiRgb(fgDel);
+        if (!addRgb || !delRgb)
+            return;
+        let addBase = { r: 0, g: 0, b: 0 };
+        let delBase = addBase;
+        if (theme.getBgAnsi) {
+            try {
+                const successBgAnsi = theme.getBgAnsi("toolSuccessBg");
+                const successParsed = parseAnsiRgb(successBgAnsi);
+                if (successParsed) {
+                    addBase = successParsed;
+                    delBase = successParsed;
+                    BG_BASE = successBgAnsi;
+                }
+            }
+            catch {
+                /* no toolSuccessBg — use black */
+            }
+            try {
+                const errorParsed = parseAnsiRgb(theme.getBgAnsi("toolErrorBg"));
+                if (errorParsed)
+                    delBase = errorParsed;
+            }
+            catch {
+                /* no toolErrorBg — use toolSuccessBg/black */
+            }
+        }
+        // Line backgrounds — subtle accent mixed into the matching tool-state base (8–10%)
+        BG_ADD = mixBg(addBase, addRgb, 0.08);
+        BG_DEL = mixBg(delBase, delRgb, 0.1);
+        // Word-level highlights — more visible (20–22%)
+        BG_ADD_W = mixBg(addBase, addRgb, 0.2);
+        BG_DEL_W = mixBg(delBase, delRgb, 0.22);
+        // Gutters — subtler than lines (5–6%)
+        BG_GUTTER_ADD = mixBg(addBase, addRgb, 0.05);
+        BG_GUTTER_DEL = mixBg(delBase, delRgb, 0.06);
+        // Empty filler and context — match the success/context base
+        BG_EMPTY = BG_BASE;
+        // Update RST to re-apply base bg after every reset — prevents black
+        // flashes between styled segments when toolSuccessBg is non-black
+        RST = `\x1b[0m${BG_BASE}`;
+        // Rebuild derived constants
+        DIVIDER = `${FG_RULE}│${RST}`;
+    }
+    catch {
+        // Fall back to defaults silently
+    }
+}
+/** Load diff theme config from .pi/settings.json (project-level, then global). */
+function loadDiffConfig() {
+    const paths = [`${process.cwd()}/.pi/settings.json`, `${process.env.HOME ?? ""}/.pi/settings.json`];
+    for (const p of paths) {
+        try {
+            if ((0, node_fs_1.existsSync)(p)) {
+                const raw = JSON.parse((0, node_fs_1.readFileSync)(p, "utf-8"));
+                if (raw.diffTheme || raw.diffColors) {
+                    return { diffTheme: raw.diffTheme, diffColors: raw.diffColors };
+                }
+            }
+        }
+        catch {
+            // skip invalid files
+        }
+    }
+    return {};
+}
+/** Apply diff palette from settings → preset → (auto-derive deferred) → defaults.
+ *  Called once during extension initialization. */
+function applyDiffPalette() {
+    const config = loadDiffConfig();
+    // Load preset if specified
+    const preset = config.diffTheme ? DIFF_PRESETS[config.diffTheme] : null;
+    if (preset)
+        _hasExplicitBgConfig = true;
+    // Per-color overrides from settings
+    const ov = config.diffColors ?? {};
+    if (Object.keys(ov).length > 0)
+        _hasExplicitBgConfig = true;
+    // Helper: apply a hex bg color if not env-overridden
+    const applyBg = (envName, key, presetVal, set) => {
+        if (envName && process.env[envName])
+            return; // env override wins
+        const hex = ov[key] ?? presetVal;
+        if (hex) {
+            const a = hexToBgAnsi(hex);
+            if (a)
+                set(a);
+        }
+    };
+    // Helper: apply a hex fg color if not env-overridden
+    const applyFg = (envName, key, presetVal, set) => {
+        if (envName && process.env[envName])
+            return;
+        const hex = ov[key] ?? presetVal;
+        if (hex) {
+            const a = hexToFgAnsi(hex);
+            if (a)
+                set(a);
+        }
+    };
+    // --- Apply backgrounds ---
+    applyBg("DIFF_BG_ADD", "bgAdd", preset?.bgAdd, (v) => {
+        BG_ADD = v;
+    });
+    applyBg("DIFF_BG_DEL", "bgDel", preset?.bgDel, (v) => {
+        BG_DEL = v;
+    });
+    applyBg("DIFF_BG_ADD_HL", "bgAddHighlight", preset?.bgAddHighlight, (v) => {
+        BG_ADD_W = v;
+    });
+    applyBg("DIFF_BG_DEL_HL", "bgDelHighlight", preset?.bgDelHighlight, (v) => {
+        BG_DEL_W = v;
+    });
+    applyBg("DIFF_BG_GUTTER_ADD", "bgGutterAdd", preset?.bgGutterAdd, (v) => {
+        BG_GUTTER_ADD = v;
+    });
+    applyBg("DIFF_BG_GUTTER_DEL", "bgGutterDel", preset?.bgGutterDel, (v) => {
+        BG_GUTTER_DEL = v;
+    });
+    applyBg(null, "bgEmpty", preset?.bgEmpty, (v) => {
+        BG_EMPTY = v;
+    });
+    // --- Apply foregrounds ---
+    applyFg("DIFF_FG_ADD", "fgAdd", preset?.fgAdd, (v) => {
+        FG_ADD = v;
+    });
+    applyFg("DIFF_FG_DEL", "fgDel", preset?.fgDel, (v) => {
+        FG_DEL = v;
+    });
+    applyFg(null, "fgDim", preset?.fgDim, (v) => {
+        FG_DIM = v;
+    });
+    applyFg(null, "fgLnum", preset?.fgLnum, (v) => {
+        FG_LNUM = v;
+    });
+    applyFg(null, "fgRule", preset?.fgRule, (v) => {
+        FG_RULE = v;
+    });
+    applyFg(null, "fgStripe", preset?.fgStripe, (v) => {
+        FG_STRIPE = v;
+    });
+    applyFg(null, "fgSafeMuted", preset?.fgSafeMuted, (v) => {
+        FG_SAFE_MUTED = v;
+    });
+    // --- Shiki syntax theme ---
+    const shiki = ov.shikiTheme ?? preset?.shikiTheme;
+    if (shiki)
+        THEME = shiki;
+    // --- Rebuild derived constants ---
+    DIVIDER = `${FG_RULE}│${RST}`;
+    DEFAULT_DIFF_COLORS = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
+    // If no explicit bg config, auto-derive will run on first render
+    _autoDerivePending = !_hasExplicitBgConfig;
+}
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+let THEME = process.env.DIFF_THEME ?? "github-dark";
+function envInt(name, fallback) {
+    const v = Number.parseInt(process.env[name] ?? "", 10);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+/** Parse env hex color "#RRGGBB" → ANSI 24-bit fg/bg escape, or return fallback. */
+function envFg(name, fallback) {
+    const hex = process.env[name];
+    if (!hex || !/^#[0-9a-fA-F]{6}$/.test(hex))
+        return fallback;
+    const r = Number.parseInt(hex.slice(1, 3), 16);
+    const g = Number.parseInt(hex.slice(3, 5), 16);
+    const b = Number.parseInt(hex.slice(5, 7), 16);
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+function envBg(name, fallback) {
+    const hex = process.env[name];
+    if (!hex || !/^#[0-9a-fA-F]{6}$/.test(hex))
+        return fallback;
+    const r = Number.parseInt(hex.slice(1, 3), 16);
+    const g = Number.parseInt(hex.slice(3, 5), 16);
+    const b = Number.parseInt(hex.slice(5, 7), 16);
+    return `\x1b[48;2;${r};${g};${b}m`;
+}
+// --- Split-view thresholds ---
+// Split is preferred when there's real room. At narrow widths, a clean stacked
+// (unified) view is better than a cramped split with wrapping.
+const SPLIT_MIN_WIDTH = envInt("DIFF_SPLIT_MIN_WIDTH", 150); // need ≥150 cols for split to breathe
+const SPLIT_MIN_CODE_WIDTH = envInt("DIFF_SPLIT_MIN_CODE_WIDTH", 60); // ≥60 code cols per side
+const SPLIT_MAX_WRAP_RATIO = 0.2; // if >20% lines wrap in split, fall back to stacked
+const SPLIT_MAX_WRAP_LINES = 8; // absolute cap before unified fallback
+// --- Terminal bounds ---
+const MAX_TERM_WIDTH = 210; // max for 1728px wide display (~205 cols at typical font)
+const DEFAULT_TERM_WIDTH = 200; // safe default for 1728x1117 resolution
+// --- Rendering limits ---
+const MAX_PREVIEW_LINES = 60; // was 50 — show slightly more context in edit preview
+const MAX_RENDER_LINES = 150; // was 120 — show more of the diff in write tool
+const MAX_HL_CHARS = 80_000; // was 50k — allow syntax hl for larger diffs
+const CACHE_LIMIT = 192; // was 128 — bigger cache for multi-file sessions
+// --- Word diff ---
+const WORD_DIFF_MIN_SIM = 0.15; // was 0.2 — show word diffs for slightly less similar lines
+// --- Wrapping ---
+// Adaptive: narrow terminals truncate aggressively, wide terminals allow wrapping.
+// Actual wrap rows are computed per-render via adaptiveWrapRows().
+const MAX_WRAP_ROWS_WIDE = 3; // ≥180 cols
+const MAX_WRAP_ROWS_MED = 2; // 120–179 cols
+const MAX_WRAP_ROWS_NARROW = 1; // <120 cols (truncate, no wrap)
+// ---------------------------------------------------------------------------
+// ANSI
+// ---------------------------------------------------------------------------
+let RST = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+// Subtle diff backgrounds — muted tones to let syntax fg shine through
+// Override via env: DIFF_BG_ADD="#1a3320" etc. (hex "#RRGGBB" format)
+let BG_ADD = envBg("DIFF_BG_ADD", "\x1b[48;2;22;38;32m"); // muted teal-green
+let BG_DEL = envBg("DIFF_BG_DEL", "\x1b[48;2;45;25;25m"); // muted brown-red
+let BG_ADD_W = envBg("DIFF_BG_ADD_HL", "\x1b[48;2;35;75;50m"); // word-level emphasis
+let BG_DEL_W = envBg("DIFF_BG_DEL_HL", "\x1b[48;2;80;35;35m");
+let BG_GUTTER_ADD = envBg("DIFF_BG_GUTTER_ADD", "\x1b[48;2;18;32;26m");
+let BG_GUTTER_DEL = envBg("DIFF_BG_GUTTER_DEL", "\x1b[48;2;38;22;22m");
+const BG_GUTTER_CTX = ""; // use terminal default bg for context gutters
+let BG_EMPTY = "\x1b[48;2;18;18;18m"; // filler rows when one side is shorter
+// Diff foregrounds — override via env: DIFF_FG_ADD="#50d264" etc.
+let FG_ADD = envFg("DIFF_FG_ADD", "\x1b[38;2;100;180;120m"); // desaturated green
+let FG_DEL = envFg("DIFF_FG_DEL", "\x1b[38;2;200;100;100m"); // desaturated red
+let FG_DIM = "\x1b[38;2;80;80;80m";
+let FG_LNUM = "\x1b[38;2;100;100;100m";
+let FG_RULE = "\x1b[38;2;50;50;50m";
+let FG_SAFE_MUTED = "\x1b[38;2;139;148;158m";
+let FG_STRIPE = "\x1b[38;2;40;40;40m"; // gray diagonal stripes on terminal default bg
+const BORDER_BAR = "▌";
+/** Generate a dense diagonal stripe fill for empty filler cells.
+ *  Solid ╱ characters — uniform direction like CSS diagonal hatching. */
+function stripes(w, _rowOffset) {
+    return BG_BASE + FG_STRIPE + "╱".repeat(w) + RST;
+}
+let DIVIDER = `${FG_RULE}│${RST}`;
+const ESC_RE = "\u001b";
+const ANSI_RE = new RegExp(`${ESC_RE}\\[[0-9;]*m`, "g");
+const ANSI_CAPTURE_RE = new RegExp(`${ESC_RE}\\[([^m]*)m`, "g");
+const ANSI_PARAM_CAPTURE_RE = new RegExp(`${ESC_RE}\\[([0-9;]*)m`, "g");
+const BG_DEFAULT = "\x1b[49m"; // reset to terminal default background
+let BG_BASE = BG_DEFAULT; // tool box base bg — updated from theme's toolSuccessBg
+let DEFAULT_DIFF_COLORS = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
+let _lastResolvedThemeKey = "";
+function themeCacheKey(theme) {
+    if (!theme?.fg)
+        return "no-theme";
+    const fgKeys = [
+        "toolTitle",
+        "accent",
+        "muted",
+        "success",
+        "error",
+        "toolDiffAdded",
+        "toolDiffRemoved",
+        "toolDiffContext",
+    ];
+    const bgKeys = ["toolSuccessBg", "toolErrorBg"];
+    const parts = [];
+    for (const key of fgKeys) {
+        try {
+            parts.push(theme.fg(key, key));
+        }
+        catch {
+            parts.push(key);
+        }
+    }
+    for (const key of bgKeys) {
+        try {
+            parts.push(theme.bg ? theme.bg(key, key) : key);
+        }
+        catch {
+            parts.push(key);
+        }
+    }
+    return parts.join("|");
+}
+/** Resolve diff fg colors from theme (if available), falling back to hardcoded ANSI.
+ *  On first call with a valid theme, auto-derives bg colors if no explicit config was set.
+ *  Always reads toolSuccessBg for BG_BASE (used for context/add line backgrounds). */
+function resolveDiffColors(theme) {
+    const currentThemeKey = themeCacheKey(theme);
+    if (!_hasExplicitBgConfig && _lastResolvedThemeKey && _lastResolvedThemeKey !== currentThemeKey) {
+        BG_BASE = BG_DEFAULT;
+        RST = "\x1b[0m";
+        _autoDerivePending = true;
+    }
+    _lastResolvedThemeKey = currentThemeKey;
+    // Always read toolSuccessBg for BG_BASE (even with explicit config)
+    if (theme?.getBgAnsi && BG_BASE === BG_DEFAULT) {
+        try {
+            const bgAnsi = theme.getBgAnsi("toolSuccessBg");
+            const parsed = parseAnsiRgb(bgAnsi);
+            if (parsed) {
+                BG_BASE = bgAnsi;
+                RST = `\x1b[0m${BG_BASE}`;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    // Auto-derive bg colors from theme on first render (if no explicit preset/overrides)
+    if (_autoDerivePending && theme?.getFgAnsi) {
+        autoDeriveBgFromTheme(theme);
+        _autoDerivePending = false;
+    }
+    if (!theme?.getFgAnsi)
+        return DEFAULT_DIFF_COLORS;
+    try {
+        const fgAdd = theme.getFgAnsi("toolDiffAdded") || FG_ADD;
+        const fgDel = theme.getFgAnsi("toolDiffRemoved") || FG_DEL;
+        const fgCtx = theme.getFgAnsi("toolDiffContext") || FG_DIM;
+        return { fgAdd, fgDel, fgCtx };
+    }
+    catch {
+        return DEFAULT_DIFF_COLORS;
+    }
+}
+// ---------------------------------------------------------------------------
+// Adaptive helpers
+// ---------------------------------------------------------------------------
+/** Returns max wrap rows based on current terminal width. Narrow = truncate, wide = allow wrapping. */
+function adaptiveWrapRows(tw) {
+    const w = tw ?? termW();
+    if (w >= 180)
+        return MAX_WRAP_ROWS_WIDE;
+    if (w >= 120)
+        return MAX_WRAP_ROWS_MED;
+    return MAX_WRAP_ROWS_NARROW;
+}
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+function strip(s) {
+    return s.replace(ANSI_RE, "");
+}
+function tabs(s) {
+    return s.replace(/\t/g, "  ");
+}
+function termW() {
+    // Try multiple sources — process.stdout.columns may be undefined in piped/subagent contexts
+    const raw = process.stdout.columns ||
+        process.stderr.columns ||
+        Number.parseInt(process.env.COLUMNS ?? "", 10) ||
+        DEFAULT_TERM_WIDTH;
+    return Math.max(80, Math.min(raw - 4, MAX_TERM_WIDTH)); // -4 safety margin for pi TUI padding
+}
+/** Pad/truncate `s` to exactly `w` visible chars. ANSI-aware. */
+function fit(s, w) {
+    if (w <= 0)
+        return "";
+    const plain = strip(s);
+    if (plain.length <= w)
+        return s + " ".repeat(w - plain.length);
+    // Truncated — show content + dim › indicator
+    const showW = w > 2 ? w - 1 : w;
+    let vis = 0, i = 0;
+    while (i < s.length && vis < showW) {
+        if (s[i] === "\x1b") {
+            const e = s.indexOf("m", i);
+            if (e !== -1) {
+                i = e + 1;
+                continue;
+            }
+        }
+        vis++;
+        i++;
+    }
+    return w > 2 ? `${s.slice(0, i)}${RST}${FG_DIM}›${RST}` : `${s.slice(0, i)}${RST}`;
+}
+/** Extract last active fg + bg ANSI codes from a string. Used for wrapping continuations. */
+function ansiState(s) {
+    let fg = "", bg = "";
+    for (const match of s.matchAll(ANSI_CAPTURE_RE)) {
+        const p = match[1] ?? "";
+        const seq = match[0] ?? "";
+        if (p === "0") {
+            fg = "";
+            bg = "";
+        }
+        else if (p === "39") {
+            fg = "";
+        }
+        else if (p.startsWith("38;")) {
+            fg = seq;
+        }
+        else if (p.startsWith("48;")) {
+            bg = seq;
+        }
+    }
+    return bg + fg;
+}
+function isLowContrastShikiFg(params) {
+    if (params === "30" || params === "90")
+        return true;
+    if (params === "38;5;0" || params === "38;5;8")
+        return true;
+    if (!params.startsWith("38;2;"))
+        return false;
+    const parts = params.split(";").map(Number);
+    if (parts.length !== 5 || parts.some((n) => !Number.isFinite(n)))
+        return false;
+    const [, , r, g, b] = parts;
+    const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    return luminance < 72;
+}
+function normalizeShikiContrast(ansi) {
+    return ansi.replace(ANSI_PARAM_CAPTURE_RE, (seq, params) => isLowContrastShikiFg(params) ? FG_SAFE_MUTED : seq);
+}
+/** Wrap ANSI-encoded string into rows of `w` visible chars. Max `maxRows` rows; last row truncates with ›. */
+function wrapAnsi(s, w, maxRows = adaptiveWrapRows(), fillBg = "") {
+    if (w <= 0)
+        return [""];
+    const plain = strip(s);
+    if (plain.length <= w) {
+        const pad = w - plain.length;
+        return pad > 0 ? [s + fillBg + " ".repeat(pad) + (fillBg ? RST : "")] : [s];
+    }
+    const rows = [];
+    let row = "", vis = 0, i = 0;
+    let onLastRow = false;
+    let effW = w;
+    while (i < s.length) {
+        // When we reach the last allowed row, reserve 1 char for › indicator
+        if (!onLastRow && rows.length >= maxRows - 1) {
+            onLastRow = true;
+            effW = w > 2 ? w - 1 : w;
+        }
+        // Pass through ANSI escapes
+        if (s[i] === "\x1b") {
+            const end = s.indexOf("m", i);
+            if (end !== -1) {
+                row += s.slice(i, end + 1);
+                i = end + 1;
+                continue;
+            }
+        }
+        // Row full
+        if (vis >= effW) {
+            if (onLastRow) {
+                // Check if remaining string has visible chars
+                let hasMore = false;
+                for (let j = i; j < s.length; j++) {
+                    if (s[j] === "\x1b") {
+                        const e2 = s.indexOf("m", j);
+                        if (e2 !== -1) {
+                            j = e2;
+                            continue;
+                        }
+                    }
+                    hasMore = true;
+                    break;
+                }
+                if (hasMore && w > 2)
+                    row += `${RST}${FG_DIM}›${RST}`;
+                else
+                    row += fillBg + " ".repeat(Math.max(0, w - vis)) + RST;
+                rows.push(row);
+                return rows;
+            }
+            // Normal wrap — carry ANSI state forward
+            const state = ansiState(row);
+            rows.push(row + RST);
+            row = state + fillBg;
+            vis = 0;
+            if (rows.length >= maxRows - 1) {
+                onLastRow = true;
+                effW = w > 2 ? w - 1 : w;
+            }
+        }
+        row += s[i];
+        vis++;
+        i++;
+    }
+    // Final row, padded
+    if (row.length > 0 || rows.length === 0) {
+        rows.push(row + fillBg + " ".repeat(Math.max(0, w - vis)) + RST);
+    }
+    return rows;
+}
+function lnum(n, w, fg = FG_LNUM) {
+    if (n === null)
+        return " ".repeat(w);
+    const v = String(n);
+    return `${fg}${" ".repeat(Math.max(0, w - v.length))}${v}${RST}`;
+}
+function shortPath(cwd, home, p) {
+    if (!p)
+        return "";
+    const r = (0, node_path_1.relative)(cwd, p);
+    if (!r.startsWith("..") && !r.startsWith("/"))
+        return r;
+    return p.replace(home, "~");
+}
+function summarize(a, d) {
+    const p = [];
+    if (a > 0)
+        p.push(`${FG_ADD}+${a}${RST}`);
+    if (d > 0)
+        p.push(`${FG_DEL}-${d}${RST}`);
+    return p.length ? p.join(" ") : `${FG_DIM}no changes${RST}`;
+}
+function rule(w) {
+    return `${BG_BASE}${FG_RULE}${"─".repeat(w)}${RST}`;
+}
+/**
+ * Decide whether split view is readable for the given terminal width.
+ * Prefers split view — side-by-side is always easier to scan.
+ * Falls back to unified only when code columns would be too cramped
+ * or too many lines would wrap even with adaptive truncation.
+ */
+function shouldUseSplit(diff, tw, maxRows = MAX_PREVIEW_LINES) {
+    if (!diff.lines.length)
+        return false;
+    if (tw < SPLIT_MIN_WIDTH)
+        return false;
+    const nw = Math.max(2, String(Math.max(...diff.lines.map((l) => l.oldNum ?? l.newNum ?? 0), 0)).length);
+    const half = Math.floor((tw - 1) / 2); // -1 for center divider
+    const gw = nw + 5; // border + num + sign + sp + │ + sp
+    const cw = Math.max(12, half - gw);
+    if (cw < SPLIT_MIN_CODE_WIDTH)
+        return false;
+    // Estimate how many lines would need wrapping at this code width
+    const vis = diff.lines.slice(0, maxRows);
+    let contentLines = 0;
+    let wrapCandidates = 0;
+    for (const l of vis) {
+        if (l.type === "sep")
+            continue;
+        contentLines++;
+        if (tabs(l.content).length > cw)
+            wrapCandidates++;
+    }
+    if (contentLines === 0)
+        return true;
+    const wrapRatio = wrapCandidates / contentLines;
+    if (wrapCandidates >= SPLIT_MAX_WRAP_LINES)
+        return false;
+    if (wrapRatio >= SPLIT_MAX_WRAP_RATIO)
+        return false;
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Language detection
+// ---------------------------------------------------------------------------
+const EXT_LANG = {
+    ts: "typescript",
+    tsx: "tsx",
+    js: "javascript",
+    jsx: "jsx",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    rb: "ruby",
+    rs: "rust",
+    go: "go",
+    java: "java",
+    c: "c",
+    cpp: "cpp",
+    h: "c",
+    hpp: "cpp",
+    cs: "csharp",
+    swift: "swift",
+    kt: "kotlin",
+    html: "html",
+    css: "css",
+    scss: "scss",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml",
+    toml: "toml",
+    md: "markdown",
+    sql: "sql",
+    sh: "bash",
+    bash: "bash",
+    zsh: "bash",
+    lua: "lua",
+    php: "php",
+    dart: "dart",
+    xml: "xml",
+    graphql: "graphql",
+    svelte: "svelte",
+    vue: "vue",
+};
+function lang(fp) {
+    return EXT_LANG[(0, node_path_1.extname)(fp).slice(1).toLowerCase()];
+}
+// ---------------------------------------------------------------------------
+// Shiki ANSI cache + pre-warm
+// ---------------------------------------------------------------------------
+// Pre-warm the Shiki singleton (loads WASM grammars + theme) so the first
+// diff render doesn't pay the ~200-500ms startup cost.
+(0, cli_1.codeToANSI)("", "typescript", THEME).catch(() => { });
+const _cache = new Map();
+function _touch(k, v) {
+    _cache.delete(k);
+    _cache.set(k, v);
+    while (_cache.size > CACHE_LIMIT) {
+        const first = _cache.keys().next().value;
+        if (first === undefined)
+            break;
+        _cache.delete(first);
+    }
+    return v;
+}
+async function hlBlock(code, language) {
+    if (!code)
+        return [""];
+    if (!language || code.length > MAX_HL_CHARS)
+        return code.split("\n");
+    const k = `${THEME}\0${language}\0${code}`;
+    const hit = _cache.get(k);
+    if (hit)
+        return _touch(k, hit);
+    try {
+        const ansi = normalizeShikiContrast(await (0, cli_1.codeToANSI)(code, language, THEME));
+        const out = (ansi.endsWith("\n") ? ansi.slice(0, -1) : ansi).split("\n");
+        return _touch(k, out);
+    }
+    catch {
+        return code.split("\n");
+    }
+}
+// ---------------------------------------------------------------------------
+// Word diff + bg injection
+//
+// Key insight: Shiki's codeToANSI only emits fg codes (\x1b[38;...m and
+// \x1b[39m). It never sets backgrounds.  So we can layer a diff bg underneath
+// and it persists through all fg switches.  For word-level emphasis we swap
+// the bg to a brighter shade at changed character positions.
+// ---------------------------------------------------------------------------
+/**
+ * Combined word diff analysis — single Diff.diffWords() call returns both
+ * similarity score and character ranges for emphasis highlighting.
+ * Replaces separate wordDiffRanges + wordDiffSimilarity (which called diffWords twice).
+ */
+function wordDiffAnalysis(a, b) {
+    if (!a && !b)
+        return { similarity: 1, oldRanges: [], newRanges: [] };
+    const parts = Diff.diffWords(a, b);
+    const oldRanges = [];
+    const newRanges = [];
+    let oPos = 0, nPos = 0, same = 0;
+    for (const p of parts) {
+        if (p.removed) {
+            oldRanges.push([oPos, oPos + p.value.length]);
+            oPos += p.value.length;
+        }
+        else if (p.added) {
+            newRanges.push([nPos, nPos + p.value.length]);
+            nPos += p.value.length;
+        }
+        else {
+            const len = p.value.length;
+            same += len;
+            oPos += len;
+            nPos += len;
+        }
+    }
+    const maxLen = Math.max(a.length, b.length);
+    return { similarity: maxLen > 0 ? same / maxLen : 1, oldRanges, newRanges };
+}
+/**
+ * Inject diff background into Shiki ANSI output.
+ * `baseBg` on unchanged spans, `hlBg` on changed character ranges.
+ * Re-injects bg after any full reset (\x1b[0m).
+ *
+ * Uses sorted-range pointer scan instead of Set (avoids O(totalChars) Set creation).
+ */
+function injectBg(ansiLine, ranges, baseBg, hlBg) {
+    if (!ranges.length)
+        return baseBg + ansiLine + RST;
+    let out = baseBg;
+    let vis = 0;
+    let inHL = false;
+    let ri = 0; // current range index
+    let i = 0;
+    while (i < ansiLine.length) {
+        if (ansiLine[i] === "\x1b") {
+            const m = ansiLine.indexOf("m", i);
+            if (m !== -1) {
+                const seq = ansiLine.slice(i, m + 1);
+                out += seq;
+                // Re-inject bg after full reset
+                if (seq === "\x1b[0m")
+                    out += inHL ? hlBg : baseBg;
+                i = m + 1;
+                continue;
+            }
+        }
+        // Advance past exhausted ranges
+        while (ri < ranges.length && vis >= ranges[ri][1])
+            ri++;
+        const want = ri < ranges.length && vis >= ranges[ri][0] && vis < ranges[ri][1];
+        if (want !== inHL) {
+            inHL = want;
+            out += inHL ? hlBg : baseBg;
+        }
+        out += ansiLine[i];
+        vis++;
+        i++;
+    }
+    return out + RST;
+}
+/** Simple word diff (no syntax hl) — fallback when Shiki isn't available. */
+function plainWordDiff(oldText, newText) {
+    const parts = Diff.diffWords(oldText, newText);
+    let o = "", n = "";
+    for (const p of parts) {
+        if (p.removed)
+            o += `${BG_DEL_W}${p.value}${RST}${BG_DEL}`;
+        else if (p.added)
+            n += `${BG_ADD_W}${p.value}${RST}${BG_ADD}`;
+        else {
+            o += p.value;
+            n += p.value;
+        }
+    }
+    return { old: o, new: n };
+}
+// ---------------------------------------------------------------------------
+// Stacked (unified) view — clean single-column layout
+//
+// Modelled after Shiki diff/GitHub stacked view:
+//   • Single line-number column (shows old num for del/ctx, new num for add)
+//   • Compact gutter: "NNN-│" or "NNN+│" or "NNN │"
+//   • Full-width code — no side-by-side cramming
+//   • Hunk separators as "··· N unmodified lines ···"
+//   • Paired del/add lines adjacent with word-level emphasis
+// ---------------------------------------------------------------------------
+async function renderUnified(diff, language, max = MAX_RENDER_LINES, dc = DEFAULT_DIFF_COLORS) {
+    if (!diff.lines.length)
+        return "";
+    const vis = diff.lines.slice(0, max);
+    const tw = termW();
+    const nw = Math.max(2, String(Math.max(...vis.map((l) => l.oldNum ?? l.newNum ?? 0), 0)).length);
+    const gw = nw + 5; // border + num + sign + sp + │ + sp
+    const cw = Math.max(20, tw - gw);
+    const canHL = diff.chars <= MAX_HL_CHARS && vis.length <= MAX_RENDER_LINES;
+    // Build separate old/new code blocks for highlighting
+    const oldSrc = [], newSrc = [];
+    for (const l of vis) {
+        if (l.type === "ctx" || l.type === "del")
+            oldSrc.push(l.content);
+        if (l.type === "ctx" || l.type === "add")
+            newSrc.push(l.content);
+    }
+    const [oldHL, newHL] = canHL
+        ? await Promise.all([hlBlock(oldSrc.join("\n"), language), hlBlock(newSrc.join("\n"), language)])
+        : [oldSrc, newSrc];
+    let oI = 0, nI = 0, idx = 0;
+    const out = [];
+    out.push(rule(tw));
+    /** Emit a single stacked row with compact gutter + left border bar. */
+    function emitRow(num, sign, gutterBg, signFg, body, bodyBg = "") {
+        const borderFg = sign === "-" ? dc.fgDel : sign === "+" ? dc.fgAdd : "";
+        const border = borderFg ? `${borderFg}${BORDER_BAR}${RST}` : `${BG_BASE} `;
+        const numFg = borderFg || FG_LNUM;
+        const gutter = `${border}${gutterBg}${lnum(num, nw, numFg)}${signFg}${sign}${RST} ${DIVIDER} `;
+        const contGutter = `${border}${gutterBg}${" ".repeat(nw + 1)}${RST} ${DIVIDER} `;
+        const rows = wrapAnsi(tabs(body), cw, adaptiveWrapRows(), bodyBg);
+        out.push(`${gutter}${rows[0]}${RST}`);
+        for (let r = 1; r < rows.length; r++)
+            out.push(`${contGutter}${rows[r]}${RST}`);
+    }
+    while (idx < vis.length) {
+        const l = vis[idx];
+        // Hunk separator — collapsed context
+        if (l.type === "sep") {
+            const gap = l.newNum;
+            const label = gap && gap > 0 ? ` ${gap} unmodified lines ` : "···";
+            const totalW = Math.min(tw, 72);
+            const pad = Math.max(0, totalW - label.length - 2);
+            const half1 = Math.floor(pad / 2), half2 = pad - half1;
+            out.push(`${BG_BASE}${FG_DIM}${"─".repeat(half1)}${label}${"─".repeat(half2)}${RST}`);
+            idx++;
+            continue;
+        }
+        // Context line — dimmed, single line number
+        if (l.type === "ctx") {
+            const hl = oldHL[oI] ?? l.content;
+            emitRow(l.newNum, " ", BG_BASE, dc.fgCtx, `${BG_BASE}${DIM}${hl}`, BG_BASE);
+            oI++;
+            nI++;
+            idx++;
+            continue;
+        }
+        // Collect del/add blocks
+        const dels = [];
+        while (idx < vis.length && vis[idx].type === "del") {
+            dels.push({ l: vis[idx], hl: oldHL[oI] ?? vis[idx].content });
+            oI++;
+            idx++;
+        }
+        const adds = [];
+        while (idx < vis.length && vis[idx].type === "add") {
+            adds.push({ l: vis[idx], hl: newHL[nI] ?? vis[idx].content });
+            nI++;
+            idx++;
+        }
+        // 1:1 paired → word diff emphasis
+        const isPaired = dels.length === 1 && adds.length === 1;
+        const wd = isPaired ? wordDiffAnalysis(dels[0].l.content, adds[0].l.content) : null;
+        if (isPaired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && canHL) {
+            const delBody = injectBg(dels[0].hl, wd.oldRanges, BG_DEL, BG_DEL_W);
+            const addBody = injectBg(adds[0].hl, wd.newRanges, BG_ADD, BG_ADD_W);
+            emitRow(dels[0].l.oldNum, "-", BG_GUTTER_DEL, `${dc.fgDel}${BOLD}`, delBody, BG_DEL);
+            emitRow(adds[0].l.newNum, "+", BG_GUTTER_ADD, `${dc.fgAdd}${BOLD}`, addBody, BG_ADD);
+            continue;
+        }
+        if (isPaired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && !canHL) {
+            const pwd = plainWordDiff(dels[0].l.content, adds[0].l.content);
+            emitRow(dels[0].l.oldNum, "-", BG_GUTTER_DEL, `${dc.fgDel}${BOLD}`, `${BG_DEL}${pwd.old}`, BG_DEL);
+            emitRow(adds[0].l.newNum, "+", BG_GUTTER_ADD, `${dc.fgAdd}${BOLD}`, `${BG_ADD}${pwd.new}`, BG_ADD);
+            continue;
+        }
+        // Multi-line blocks — syntax highlighted with diff bg
+        for (const d of dels) {
+            const body = canHL ? `${BG_DEL}${d.hl}` : `${BG_DEL}${d.l.content}`;
+            emitRow(d.l.oldNum, "-", BG_GUTTER_DEL, `${dc.fgDel}${BOLD}`, body, BG_DEL);
+        }
+        for (const a of adds) {
+            const body = canHL ? `${BG_ADD}${a.hl}` : `${BG_ADD}${a.l.content}`;
+            emitRow(a.l.newNum, "+", BG_GUTTER_ADD, `${dc.fgAdd}${BOLD}`, body, BG_ADD);
+        }
+    }
+    out.push(rule(tw));
+    if (diff.lines.length > vis.length) {
+        out.push(`${BG_BASE}${FG_DIM}  … ${diff.lines.length - vis.length} more lines${RST}`);
+    }
+    return out.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Split view (auto-fallback to unified when narrow)
+// ---------------------------------------------------------------------------
+async function renderSplit(diff, language, max = MAX_PREVIEW_LINES, dc = DEFAULT_DIFF_COLORS) {
+    const tw = termW();
+    if (!shouldUseSplit(diff, tw, max))
+        return renderUnified(diff, language, max, dc);
+    if (!diff.lines.length)
+        return "";
+    const rows = [];
+    let i = 0;
+    while (i < diff.lines.length) {
+        const l = diff.lines[i];
+        if (l.type === "sep" || l.type === "ctx") {
+            rows.push({ left: l, right: l });
+            i++;
+            continue;
+        }
+        const dels = [], adds = [];
+        while (i < diff.lines.length && diff.lines[i].type === "del") {
+            dels.push(diff.lines[i]);
+            i++;
+        }
+        while (i < diff.lines.length && diff.lines[i].type === "add") {
+            adds.push(diff.lines[i]);
+            i++;
+        }
+        const n = Math.max(dels.length, adds.length);
+        for (let j = 0; j < n; j++)
+            rows.push({ left: dels[j] ?? null, right: adds[j] ?? null });
+    }
+    const vis = rows.slice(0, max);
+    const half = Math.floor((tw - 1) / 2); // -1 for center divider
+    const nw = Math.max(2, String(Math.max(...diff.lines.map((l) => l.oldNum ?? l.newNum ?? 0), 0)).length);
+    const gw = nw + 5; // border + num + sign + sp + │ + sp
+    const cw = Math.max(12, half - gw);
+    const canHL = diff.chars <= MAX_HL_CHARS && vis.length * 2 <= MAX_RENDER_LINES * 2;
+    // Build separate code blocks per side
+    const leftSrc = [], rightSrc = [];
+    for (const r of vis) {
+        if (r.left && r.left.type !== "sep")
+            leftSrc.push(r.left.content);
+        if (r.right && r.right.type !== "sep")
+            rightSrc.push(r.right.content);
+    }
+    const [leftHL, rightHL] = canHL
+        ? await Promise.all([hlBlock(leftSrc.join("\n"), language), hlBlock(rightSrc.join("\n"), language)])
+        : [leftSrc, rightSrc];
+    let lI = 0, rI = 0;
+    let stripeRow = 0; // tracks row index for diagonal stripe offset
+    function half_build(line, hl, ranges, side) {
+        // Empty filler — diagonal stripes
+        if (!line) {
+            const gw2 = nw + 2; // number + sign + space before │
+            const gPat = FG_STRIPE + "╱".repeat(gw2) + RST;
+            const g = ` ${gPat}${FG_RULE}│${RST} `;
+            return { gutter: g, contGutter: g, bodyRows: [stripes(cw, stripeRow)] };
+        }
+        // Hunk separator
+        if (line.type === "sep") {
+            const gap = line.newNum;
+            const label = gap && gap > 0 ? `··· ${gap} lines ···` : "···";
+            const g = `${BG_BASE} ${FG_DIM}${fit("", nw + 2)}${RST}${FG_RULE}│${RST} `;
+            return { gutter: g, contGutter: g, bodyRows: [`${BG_BASE}${FG_DIM}${fit(label, cw)}${RST}`] };
+        }
+        const isDel = line.type === "del", isAdd = line.type === "add";
+        const gBg = isDel ? BG_GUTTER_DEL : isAdd ? BG_GUTTER_ADD : BG_BASE;
+        const cBg = isDel ? BG_DEL : isAdd ? BG_ADD : BG_BASE;
+        const sFg = isDel ? dc.fgDel : isAdd ? dc.fgAdd : dc.fgCtx;
+        const sign = isDel ? "-" : isAdd ? "+" : " ";
+        const num = isDel ? line.oldNum : isAdd ? line.newNum : side === "left" ? line.oldNum : line.newNum;
+        // Border bar + colored line numbers for changed lines
+        const borderFg = isDel ? dc.fgDel : isAdd ? dc.fgAdd : "";
+        const border = borderFg ? `${borderFg}${BORDER_BAR}${RST}` : ` ${BG_BASE}`;
+        const numFg = borderFg || FG_LNUM;
+        let body;
+        if (ranges && ranges.length > 0) {
+            body = injectBg(hl, ranges, cBg, isDel ? BG_DEL_W : BG_ADD_W);
+        }
+        else if (isDel || isAdd) {
+            body = `${cBg}${hl}`;
+        }
+        else {
+            body = `${BG_BASE}${DIM}${hl}`;
+        }
+        const gutter = `${border}${gBg}${lnum(num, nw, numFg)}${sFg}${BOLD}${sign}${RST} ${FG_RULE}│${RST} `;
+        const contGutter = `${border}${gBg}${" ".repeat(nw + 1)}${RST} ${FG_RULE}│${RST} `;
+        const bodyRows = wrapAnsi(tabs(body), cw, adaptiveWrapRows(), cBg);
+        return { gutter, contGutter, bodyRows };
+    }
+    const out = [];
+    // Column headers — "old" / "new" positioned above line numbers
+    const hdrOld = `${BG_BASE}${" ".repeat(Math.max(0, nw - 2))}${dc.fgDel}${DIM}old${RST}`;
+    const hdrNew = `${BG_BASE}${" ".repeat(Math.max(0, nw - 2))}${dc.fgAdd}${DIM}new${RST}`;
+    out.push(`${BG_BASE}${hdrOld}${" ".repeat(Math.max(0, half - nw - 1))}${FG_RULE}┊${RST}${hdrNew}`);
+    out.push(`${rule(half)}${FG_RULE}┊${RST}${rule(half)}`);
+    for (const r of vis) {
+        const leftLine = r.left, rightLine = r.right;
+        const paired = leftLine && rightLine && leftLine.type === "del" && rightLine.type === "add";
+        const wd = paired ? wordDiffAnalysis(leftLine.content, rightLine.content) : null;
+        let lResult, rResult;
+        if (paired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && canHL) {
+            const lhl = leftHL[lI++] ?? leftLine.content;
+            const rhl = rightHL[rI++] ?? rightLine.content;
+            lResult = half_build(leftLine, lhl, wd.oldRanges, "left");
+            rResult = half_build(rightLine, rhl, wd.newRanges, "right");
+        }
+        else if (paired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && !canHL) {
+            const pwd = plainWordDiff(leftLine.content, rightLine.content);
+            lI++;
+            rI++;
+            lResult = half_build(leftLine, pwd.old, null, "left");
+            rResult = half_build(rightLine, pwd.new, null, "right");
+        }
+        else {
+            const lhl = leftLine && leftLine.type !== "sep" ? (leftHL[lI++] ?? leftLine?.content ?? "") : "";
+            const rhl = rightLine && rightLine.type !== "sep" ? (rightHL[rI++] ?? rightLine?.content ?? "") : "";
+            lResult = half_build(leftLine, lhl, null, "left");
+            rResult = half_build(rightLine, rhl, null, "right");
+        }
+        // Compose wrapped rows — pad shorter side with striped continuation rows
+        const maxRows = Math.max(lResult.bodyRows.length, rResult.bodyRows.length);
+        const leftIsEmpty = !r.left;
+        const rightIsEmpty = !r.right;
+        for (let row = 0; row < maxRows; row++) {
+            const lg = row === 0 ? lResult.gutter : lResult.contGutter;
+            const rg = row === 0 ? rResult.gutter : rResult.contGutter;
+            const lb = lResult.bodyRows[row] ?? (leftIsEmpty ? stripes(cw, stripeRow) : `${BG_EMPTY}${" ".repeat(cw)}${RST}`);
+            const rb = rResult.bodyRows[row] ?? (rightIsEmpty ? stripes(cw, stripeRow) : `${BG_EMPTY}${" ".repeat(cw)}${RST}`);
+            out.push(`${lg}${lb}${DIVIDER}${rg}${rb}`);
+            stripeRow++;
+        }
+    }
+    out.push(`${rule(half)}${FG_RULE}┊${RST}${rule(half)}`);
+    if (rows.length > vis.length) {
+        out.push(`${BG_BASE}${FG_DIM}  … ${rows.length - vis.length} more lines${RST}`);
+    }
+    return out.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+exports.__testing = {
+    normalizeShikiContrast,
+    parseDiff: diff_js_1.parseDiff,
+    renderSplit,
+    renderUnified,
+};
+function reviewGitDiffMode(params) {
+    const base = typeof params.base === "string" ? params.base.trim() : "";
+    return base ? { type: "branch", base } : { type: "working-tree" };
+}
+function reviewGitDiffMaxLines(params) {
+    if (params.maxLinesPerHunk === undefined)
+        return undefined;
+    const maxLines = Number(params.maxLinesPerHunk);
+    if (!Number.isInteger(maxLines) || maxLines < 1) {
+        throw new Error("maxLinesPerHunk must be a positive integer");
+    }
+    return maxLines;
+}
+function normalizeOptionalPositiveInteger(value, name) {
+    if (value === undefined || value === null)
+        return undefined;
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < 1)
+        throw new Error(`${name} must be a positive integer`);
+    return number;
+}
+async function diffRendererExtension(pi) {
+    // Apply diff theme palette from settings/presets before rendering
+    (0, hunk_preview_js_1.applyDiffPalette)();
+    let createWriteTool, createEditTool, getMarkdownTheme, TextComponent, MarkdownComponent;
+    try {
+        const sdk = await import("@mariozechner/pi-coding-agent");
+        const tui = await import("@mariozechner/pi-tui");
+        createWriteTool = sdk.createWriteTool;
+        createEditTool = sdk.createEditTool;
+        getMarkdownTheme = sdk.getMarkdownTheme;
+        TextComponent = tui.Text;
+        MarkdownComponent = tui.Markdown;
+    }
+    catch (error) {
+        console.error(`[pi-diff] failed to load Pi SDK dependencies: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (!createWriteTool || !createEditTool || !TextComponent)
+        return;
+    const cwd = process.cwd();
+    const home = process.env.HOME ?? "";
+    const sp = (p) => shortPath(cwd, home, p);
+    const reviewComments = [];
+    (0, command_js_1.registerReviewDiffCommand)(pi, cwd);
+    pi.registerTool({
+        name: "review_git_diff",
+        label: "Review Git Diff",
+        description: `Open a read-only Git diff review panel as markdown inside Pi TUI.
+
+Use this when the agent needs structured Git review context or a non-destructive markdown view of local changes. For the real keyboard-driven local review UI, use the /review-diff command instead. This tool never stages, commits, reverts, discards, or modifies files.
+
+Examples:
+  review_git_diff({})
+  review_git_diff({ base: "main" })
+  review_git_diff({ file: "src/index.ts" })
+  review_git_diff({ file: "src/index.ts", hunkId: "src/index.ts:10:12" })`,
+        promptSnippet: "Open a read-only Git review markdown panel for local changes. Prefer /review-diff for the interactive TUI workflow.",
+        parameters: {
+            type: "object",
+            properties: {
+                base: {
+                    type: "string",
+                    description: "Optional base branch/ref. Omit for uncommitted working-tree changes; set to main/master/etc. for base...HEAD branch review.",
+                },
+                file: {
+                    type: "string",
+                    description: "Optional changed file path to focus in the interactive review panel.",
+                },
+                hunkId: {
+                    type: "string",
+                    description: "Optional hunk id to focus, shown by review_git_diff output.",
+                },
+                includeRawDiff: {
+                    type: "boolean",
+                    description: "Return legacy raw review markdown instead of the interactive panel when true.",
+                },
+                raw: {
+                    type: "boolean",
+                    description: "Alias for includeRawDiff.",
+                },
+                maxLinesPerHunk: {
+                    type: "number",
+                    description: "Optional positive integer limit for lines shown per hunk.",
+                },
+                maxFiles: {
+                    type: "number",
+                    description: "Optional positive integer limit for files shown in the changed-file sidebar.",
+                },
+                maxHunks: {
+                    type: "number",
+                    description: "Optional positive integer limit for hunks shown in the focused file view.",
+                },
+            },
+            additionalProperties: false,
+        },
+        async execute(_tid, params = {}) {
+            try {
+                const safeParams = params ?? {};
+                const diff = await (0, git_js_1.readGitDiff)(cwd, reviewGitDiffMode(safeParams));
+                const maxLinesPerHunk = reviewGitDiffMaxLines(safeParams);
+                const markdown = safeParams.includeRawDiff || safeParams.raw
+                    ? (0, export_js_1.formatReviewMarkdown)(diff, { includeRawDiff: true, maxLinesPerHunk })
+                    : (0, interactive_js_1.formatInteractiveReviewPanel)(diff, reviewComments, {
+                        file: safeParams.file,
+                        hunkId: safeParams.hunkId,
+                        maxFiles: normalizeOptionalPositiveInteger(safeParams.maxFiles, "maxFiles"),
+                        maxHunks: normalizeOptionalPositiveInteger(safeParams.maxHunks, "maxHunks"),
+                        maxLinesPerHunk,
+                    });
+                const counts = (0, git_js_1.countReviewDiffLines)(diff);
+                return {
+                    content: [{ type: "text", text: markdown }],
+                    details: {
+                        _type: "reviewGitDiff",
+                        markdown,
+                        mode: diff.mode,
+                        fileCount: diff.files.length,
+                        insertions: counts.insertions,
+                        deletions: counts.deletions,
+                        commentCount: reviewComments.length,
+                        focusedFile: safeParams.file,
+                        focusedHunk: safeParams.hunkId,
+                    },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `Error: ${message}` }],
+                    details: { _type: "reviewGitDiff", error: message },
+                };
+            }
+        },
+        renderCall(args, theme, ctx) {
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            const base = typeof args?.base === "string" && args.base.trim() ? ` vs ${args.base.trim()}` : " working tree";
+            const focus = typeof args?.file === "string" && args.file.trim() ? ` • ${args.file.trim()}` : "";
+            text.setText(`${theme.fg("toolTitle", theme.bold("review_git_diff"))}${theme.fg("muted", `${base}${focus}`)}`);
+            return text;
+        },
+        renderResult(result, _opt, theme, ctx) {
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            if (ctx.isError || result.details?.error) {
+                text.setText(`\n${theme.fg("error", result.details?.error ?? "review_git_diff failed")}`);
+                return text;
+            }
+            const details = result.details;
+            if (details?._type === "reviewGitDiff") {
+                if (MarkdownComponent && getMarkdownTheme && typeof details.markdown === "string") {
+                    return new MarkdownComponent(details.markdown, 0, 0, getMarkdownTheme());
+                }
+                const summary = `${details.fileCount} files ${summarize(details.insertions ?? 0, details.deletions ?? 0)}`;
+                const comments = details.commentCount ? ` • ${details.commentCount} comments` : "";
+                text.setText(`  ${summary}${theme.fg("muted", comments)}\n${theme.fg("muted", "  Interactive review panel generated in the tool result.")}`);
+                return text;
+            }
+            text.setText(`  ${theme.fg("muted", "interactive review generated")}`);
+            return text;
+        },
+    });
+    pi.registerTool({
+        name: "review_git_comment",
+        label: "Draft Review Comment",
+        description: "Draft an inline code-review comment for the current interactive Git review. This stores comments in memory for the current Pi session and does not modify files or submit anything externally.",
+        promptSnippet: "Draft an inline comment for the current Git review session.",
+        parameters: {
+            type: "object",
+            properties: {
+                file: { type: "string", description: "Changed file path to comment on." },
+                line: { type: "number", description: "Optional old/new line number to comment on." },
+                hunkId: { type: "string", description: "Optional hunk id from review_git_diff output." },
+                body: { type: "string", description: "Comment body." },
+            },
+            required: ["file", "body"],
+            additionalProperties: false,
+        },
+        async execute(_tid, params) {
+            const file = typeof params?.file === "string" ? params.file.trim() : "";
+            const body = typeof params?.body === "string" ? params.body.trim() : "";
+            if (!file)
+                return {
+                    content: [{ type: "text", text: "Error: file is required" }],
+                    details: { error: "file required" },
+                };
+            if (!body)
+                return {
+                    content: [{ type: "text", text: "Error: body is required" }],
+                    details: { error: "body required" },
+                };
+            const comment = (0, interactive_js_1.createReviewComment)({
+                comments: reviewComments,
+                file,
+                body,
+                line: normalizeOptionalPositiveInteger(params.line, "line"),
+                hunkId: typeof params.hunkId === "string" && params.hunkId.trim() ? params.hunkId.trim() : undefined,
+            });
+            reviewComments.push(comment);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Drafted ${comment.id} on ${comment.file}${comment.line ? `:${comment.line}` : ""}\n\n${comment.body}`,
+                    },
+                ],
+                details: { _type: "reviewGitComment", comment, commentCount: reviewComments.length },
+            };
+        },
+        renderCall(args, theme, ctx) {
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            text.setText(`${theme.fg("toolTitle", theme.bold("review_git_comment"))} ${theme.fg("accent", args?.file ?? "")}`);
+            return text;
+        },
+        renderResult(result, _opt, theme, ctx) {
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            if (ctx.isError || result.details?.error) {
+                text.setText(`\n${theme.fg("error", result.details?.error ?? "review_git_comment failed")}`);
+                return text;
+            }
+            const comment = result.details?.comment;
+            text.setText(`  ${theme.fg("success", `✓ drafted ${comment?.id ?? "comment"}`)}${theme.fg("muted", ` (${result.details?.commentCount ?? 0} total)`)}`);
+            return text;
+        },
+    });
+    pi.registerTool({
+        name: "review_git_comments",
+        label: "Review Comments",
+        description: "List or clear drafted interactive Git review comments for the current Pi session.",
+        promptSnippet: "List or clear drafted review comments.",
+        parameters: {
+            type: "object",
+            properties: {
+                clear: { type: "boolean", description: "Clear all drafted comments when true." },
+            },
+            additionalProperties: false,
+        },
+        async execute(_tid, params = {}) {
+            if (params?.clear) {
+                const cleared = reviewComments.length;
+                reviewComments.length = 0;
+                return {
+                    content: [{ type: "text", text: `Cleared ${cleared} drafted review comments.` }],
+                    details: { _type: "reviewGitComments", cleared, commentCount: 0 },
+                };
+            }
+            const markdown = (0, interactive_js_1.formatReviewComments)(reviewComments);
+            return {
+                content: [{ type: "text", text: markdown }],
+                details: { _type: "reviewGitComments", markdown, commentCount: reviewComments.length },
+            };
+        },
+        renderCall(_args, theme, ctx) {
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            text.setText(theme.fg("toolTitle", theme.bold("review_git_comments")));
+            return text;
+        },
+        renderResult(result, _opt, theme, ctx) {
+            if (MarkdownComponent && getMarkdownTheme && typeof result.details?.markdown === "string") {
+                return new MarkdownComponent(result.details.markdown, 0, 0, getMarkdownTheme());
+            }
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            const cleared = typeof result.details?.cleared === "number"
+                ? `cleared ${result.details.cleared}`
+                : `${result.details?.commentCount ?? 0} drafted`;
+            text.setText(`  ${theme.fg("muted", cleared)} review comments`);
+            return text;
+        },
+    });
+    // =======================================================================
+    // write
+    // =======================================================================
+    const origWrite = createWriteTool(cwd);
+    pi.registerTool({
+        ...origWrite,
+        name: "write",
+        async execute(tid, params, sig, upd, ctx) {
+            const fp = params.path ?? params.file_path ?? "";
+            let old = null;
+            try {
+                if (fp && (0, node_fs_1.existsSync)(fp))
+                    old = (0, node_fs_1.readFileSync)(fp, "utf-8");
+            }
+            catch {
+                old = null;
+            }
+            const result = await origWrite.execute(tid, params, sig, upd, ctx);
+            const content = params.content ?? "";
+            // Store in details — the only custom field TUI preserves in renderResult
+            if (old !== null && old !== content) {
+                const diff = (0, diff_js_1.parseDiff)(old, content);
+                const lg = (0, hunk_preview_js_1.lang)(fp);
+                result.details = { _type: "diff", summary: summarize(diff.added, diff.removed), diff, language: lg };
+            }
+            else if (old === null) {
+                const lineCount = content ? content.split("\n").length : 0;
+                result.details = { _type: "new", lines: lineCount, content: content ?? "", filePath: fp };
+            }
+            else if (old === content) {
+                result.details = { _type: "noChange" };
+            }
+            return result;
+        },
+        renderCall(args, theme, ctx) {
+            const fp = args?.path ?? args?.file_path ?? "";
+            const isNew = !fp || !(0, node_fs_1.existsSync)(fp);
+            const label = isNew ? "create" : "write";
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            const hdr = `${theme.fg("toolTitle", theme.bold(label))} ${theme.fg("accent", sp(fp))}`;
+            // Streaming
+            if (args?.content && !ctx.argsComplete) {
+                const n = String(args.content).split("\n").length;
+                text.setText(`${hdr}  ${theme.fg("muted", `(${n} lines…)`)}`);
+                return text;
+            }
+            // New file preview with Shiki
+            if (args?.content && ctx.argsComplete && isNew) {
+                const previewKey = `create:${(0, hunk_preview_js_1.themeCacheKey)(theme)}:${fp}:${String(args.content).length}`;
+                if (ctx.state._previewKey !== previewKey) {
+                    ctx.state._previewKey = previewKey;
+                    ctx.state._previewText = hdr;
+                    const lg = (0, hunk_preview_js_1.lang)(fp);
+                    hlBlock(args.content, lg)
+                        .then((lines) => {
+                        if (ctx.state._previewKey !== previewKey)
+                            return;
+                        const maxShow = ctx.expanded ? lines.length : 16;
+                        const preview = lines.slice(0, maxShow).join("\n");
+                        const rem = lines.length - maxShow;
+                        let out = `${hdr}\n\n${preview}`;
+                        if (rem > 0)
+                            out += `\n${theme.fg("muted", `… (${rem} more lines, ${lines.length} total)`)}`;
+                        ctx.state._previewText = out;
+                        ctx.invalidate();
+                    })
+                        .catch(() => { });
+                }
+                text.setText(ctx.state._previewText ?? hdr);
+                return text;
+            }
+            text.setText(hdr);
+            return text;
+        },
+        renderResult(result, _opt, theme, ctx) {
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            if (ctx.isError) {
+                const e = result.content
+                    ?.filter((c) => c.type === "text")
+                    .map((c) => c.text || "")
+                    .join("\n") ?? "Error";
+                text.setText(`\n${theme.fg("error", e)}`);
+                return text;
+            }
+            const d = result.details;
+            if (d?._type === "diff") {
+                const w = termW();
+                const key = `wd:${(0, hunk_preview_js_1.themeCacheKey)(theme)}:${w}:${d.summary}:${d.diff?.lines?.length ?? 0}:${d.language ?? ""}`;
+                if (ctx.state._wdk !== key) {
+                    ctx.state._wdk = key;
+                    ctx.state._wdt = `  ${d.summary}\n${theme.fg("muted", "  rendering diff…")}`;
+                    const dc = (0, hunk_preview_js_1.resolveDiffColors)(theme);
+                    (0, hunk_preview_js_1.renderSplit)(d.diff, d.language, MAX_RENDER_LINES, dc, w)
+                        .then((rendered) => {
+                        if (ctx.state._wdk !== key)
+                            return;
+                        ctx.state._wdt = `  ${d.summary}\n${rendered}`;
+                        ctx.invalidate();
+                    })
+                        .catch(() => {
+                        if (ctx.state._wdk !== key)
+                            return;
+                        ctx.state._wdt = `  ${d.summary}`;
+                        ctx.invalidate();
+                    });
+                }
+                text.setText(ctx.state._wdt ?? `  ${d.summary}`);
+                return text;
+            }
+            if (d?._type === "noChange") {
+                text.setText(`  ${theme.fg("muted", "✓ no changes")}`);
+                return text;
+            }
+            if (d?._type === "new") {
+                const { lines: lineCount, content: rawContent, filePath: fp } = d;
+                const pk = `nf:${(0, hunk_preview_js_1.themeCacheKey)(theme)}:${fp}:${lineCount}`;
+                if (ctx.state._nfk !== pk) {
+                    ctx.state._nfk = pk;
+                    ctx.state._nft = `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}`;
+                    const lg = (0, hunk_preview_js_1.lang)(fp);
+                    if (rawContent) {
+                        hlBlock(rawContent, lg)
+                            .then((hlLines) => {
+                            if (ctx.state._nfk !== pk)
+                                return;
+                            const maxShow = ctx.expanded ? hlLines.length : 12;
+                            const preview = hlLines.slice(0, maxShow).join("\n");
+                            const rem = hlLines.length - maxShow;
+                            let out = `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}\n${preview}`;
+                            if (rem > 0)
+                                out += `\n${theme.fg("muted", `  … ${rem} more lines`)}`;
+                            ctx.state._nft = out;
+                            ctx.invalidate();
+                        })
+                            .catch(() => { });
+                    }
+                }
+                text.setText(ctx.state._nft ?? `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}`);
+                return text;
+            }
+            text.setText(`  ${theme.fg("dim", String(result?.content?.[0]?.text ?? "written").slice(0, 120))}`);
+            return text;
+        },
+    });
+    // =======================================================================
+    // edit
+    // =======================================================================
+    const origEdit = createEditTool(cwd);
+    function getEditOperations(input) {
+        if (Array.isArray(input?.edits)) {
+            return input.edits
+                .map((edit) => ({
+                oldText: typeof edit?.oldText === "string" ? edit.oldText : typeof edit?.old_text === "string" ? edit.old_text : "",
+                newText: typeof edit?.newText === "string" ? edit.newText : typeof edit?.new_text === "string" ? edit.new_text : "",
+            }))
+                .filter((edit) => edit.oldText && edit.oldText !== edit.newText);
+        }
+        const oldText = typeof input?.oldText === "string" ? input.oldText : typeof input?.old_text === "string" ? input.old_text : "";
+        const newText = typeof input?.newText === "string" ? input.newText : typeof input?.new_text === "string" ? input.new_text : "";
+        return oldText && oldText !== newText ? [{ oldText, newText }] : [];
+    }
+    function summarizeEditOperations(operations) {
+        const diffs = operations.map((edit) => (0, diff_js_1.parseDiff)(edit.oldText, edit.newText));
+        const totalAdded = diffs.reduce((sum, diff) => sum + diff.added, 0);
+        const totalRemoved = diffs.reduce((sum, diff) => sum + diff.removed, 0);
+        return {
+            diffs,
+            totalAdded,
+            totalRemoved,
+            summary: summarize(totalAdded, totalRemoved),
+        };
+    }
+    pi.registerTool({
+        ...origEdit,
+        name: "edit",
+        async execute(tid, params, sig, upd, ctx) {
+            const fp = params.path ?? params.file_path ?? "";
+            const operations = getEditOperations(params);
+            const result = await origEdit.execute(tid, params, sig, upd, ctx);
+            if (operations.length === 0)
+                return result;
+            const { diffs, summary } = summarizeEditOperations(operations);
+            if (operations.length === 1) {
+                let editLine = 0;
+                try {
+                    if (fp && (0, node_fs_1.existsSync)(fp)) {
+                        const f = (0, node_fs_1.readFileSync)(fp, "utf-8");
+                        const idx = f.indexOf(operations[0].newText);
+                        if (idx >= 0)
+                            editLine = f.slice(0, idx).split("\n").length;
+                    }
+                }
+                catch {
+                    editLine = 0;
+                }
+                result.details = { _type: "editInfo", summary, editLine };
+                return result;
+            }
+            result.details = {
+                _type: "multiEditInfo",
+                summary,
+                editCount: operations.length,
+                diffLineCount: diffs.reduce((sum, diff) => sum + diff.lines.length, 0),
+            };
+            return result;
+        },
+        renderCall(args, theme, ctx) {
+            const fp = args?.path ?? args?.file_path ?? "";
+            const operations = getEditOperations(args);
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            const hdr = `${theme.fg("toolTitle", theme.bold("edit"))} ${theme.fg("accent", sp(fp))}`;
+            if (!(ctx.argsComplete && operations.length > 0)) {
+                text.setText(hdr);
+                return text;
+            }
+            const pk = JSON.stringify({ fp, operations, theme: (0, hunk_preview_js_1.themeCacheKey)(theme), w: termW() });
+            if (ctx.state._pk !== pk) {
+                ctx.state._pk = pk;
+                ctx.state._pt = `${hdr}  ${theme.fg("muted", "(rendering…)")}`;
+                const lg = (0, hunk_preview_js_1.lang)(fp);
+                const dc = (0, hunk_preview_js_1.resolveDiffColors)(theme);
+                if (operations.length === 1) {
+                    const diff = (0, diff_js_1.parseDiff)(operations[0].oldText, operations[0].newText);
+                    (0, hunk_preview_js_1.renderSplit)(diff, lg, MAX_PREVIEW_LINES, dc, termW())
+                        .then((rendered) => {
+                        if (ctx.state._pk !== pk)
+                            return;
+                        ctx.state._pt = `${hdr}\n${summarize(diff.added, diff.removed)}\n${rendered}`;
+                        ctx.invalidate();
+                    })
+                        .catch(() => {
+                        if (ctx.state._pk !== pk)
+                            return;
+                        ctx.state._pt = `${hdr}  ${summarize(diff.added, diff.removed)}`;
+                        ctx.invalidate();
+                    });
+                }
+                else {
+                    const { diffs, summary } = summarizeEditOperations(operations);
+                    const maxShown = Math.min(operations.length, 3);
+                    const previewLines = Math.max(8, Math.floor(MAX_PREVIEW_LINES / maxShown));
+                    Promise.all(diffs.slice(0, maxShown).map((diff, index) => (0, hunk_preview_js_1.renderSplit)(diff, lg, previewLines, dc, termW())
+                        .then((rendered) => `Edit ${index + 1}/${operations.length}\n${rendered}`)
+                        .catch(() => `Edit ${index + 1}/${operations.length}  ${summarize(diff.added, diff.removed)}`)))
+                        .then((sections) => {
+                        if (ctx.state._pk !== pk)
+                            return;
+                        const remainder = operations.length - maxShown;
+                        const suffix = remainder > 0 ? `\n${theme.fg("muted", `… ${remainder} more edit blocks`)}` : "";
+                        ctx.state._pt = `${hdr}\n${operations.length} edits ${summary}\n\n${sections.join("\n\n")}${suffix}`;
+                        ctx.invalidate();
+                    })
+                        .catch(() => {
+                        if (ctx.state._pk !== pk)
+                            return;
+                        ctx.state._pt = `${hdr}  ${operations.length} edits ${summary}`;
+                        ctx.invalidate();
+                    });
+                }
+            }
+            text.setText(ctx.state._pt ?? hdr);
+            return text;
+        },
+        renderResult(result, _opt, theme, ctx) {
+            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
+            if (ctx.isError) {
+                const e = result.content
+                    ?.filter((c) => c.type === "text")
+                    .map((c) => c.text || "")
+                    .join("\n") ?? "Error";
+                text.setText(`\n${theme.fg("error", e)}`);
+                return text;
+            }
+            if (result.details?._type === "editInfo") {
+                const { summary: s, editLine } = result.details;
+                const loc = editLine > 0 ? ` ${theme.fg("muted", `at line ${editLine}`)}` : "";
+                const content = `  ${s}${loc}`;
+                const vis = content.replace(ANSI_RE, "").length;
+                const pad = Math.max(0, termW() - vis);
+                text.setText(`${content}${" ".repeat(pad)}`);
+                return text;
+            }
+            if (result.details?._type === "multiEditInfo") {
+                const { summary: s, editCount, diffLineCount } = result.details;
+                const content = `  ${editCount} edits ${s}${typeof diffLineCount === "number" ? ` ${theme.fg("muted", `(${diffLineCount} diff lines)`)}` : ""}`;
+                const vis = content.replace(ANSI_RE, "").length;
+                const pad = Math.max(0, termW() - vis);
+                text.setText(`${content}${" ".repeat(pad)}`);
+                return text;
+            }
+            text.setText(`  ${theme.fg("dim", String(result?.content?.[0]?.text ?? "edited").slice(0, 120))}`);
+            return text;
+        },
+    });
+}
+//# sourceMappingURL=index.js.map