@heyhuynhgiabuu/pi-diff 0.2.2 → 0.3.0

package/src/index.ts

@@ -1,1635 +0,0 @@
-/**
- * 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
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import { extname, relative } from "node:path";
-
-import { codeToANSI } from "@shikijs/cli";
-import * as Diff from "diff";
-import type { BundledLanguage, BundledTheme } from "shiki";
-
-// ---------------------------------------------------------------------------
-// Diff Theme System — presets, auto-derive, and per-color overrides
-//
-// Resolution chain (per color, highest priority first):
-//   1. Environment variable override (e.g. DIFF_BG_ADD="#1a3320")
-//   2. diffColors.bgAdd from .pi/settings.json (explicit per-color hex)
-//   3. diffTheme preset value (named preset like "midnight")
-//   4. Auto-derived from pi theme fg colors (default behavior)
-//   5. Hardcoded fallback
-// ---------------------------------------------------------------------------
-
-/** Hex color palette for a diff theme preset. All values "#RRGGBB". */
-interface DiffPreset {
-	name: string;
-	description: string;
-	shikiTheme?: string;
-	bgAdd?: string;
-	bgDel?: string;
-	bgAddHighlight?: string;
-	bgDelHighlight?: string;
-	bgGutterAdd?: string;
-	bgGutterDel?: string;
-	bgEmpty?: string;
-	fgAdd?: string;
-	fgDel?: string;
-	fgDim?: string;
-	fgLnum?: string;
-	fgRule?: string;
-	fgStripe?: string;
-	fgSafeMuted?: string;
-}
-
-/** User diff config read from .pi/settings.json */
-interface DiffUserConfig {
-	diffTheme?: string;
-	diffColors?: Record<string, string>;
-}
-
-const DIFF_PRESETS: Record<string, DiffPreset> = {
-	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: string): { r: number; g: number; b: number } | null {
-	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: string): string {
-	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: string): string {
-	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: string, intensity: number): string {
-	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: { r: number; g: number; b: number },
-	accent: { r: number; g: number; b: number },
-	intensity: number,
-): string {
-	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: any): void {
-	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(): DiffUserConfig {
-	const paths = [`${process.cwd()}/.pi/settings.json`, `${process.env.HOME ?? ""}/.pi/settings.json`];
-	for (const p of paths) {
-		try {
-			if (existsSync(p)) {
-				const raw = JSON.parse(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(): void {
-	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: string | null, key: string, presetVal: string | undefined, set: (v: string) => void) => {
-		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: string | null, key: string, presetVal: string | undefined, set: (v: string) => void) => {
-		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 as BundledTheme;
-
-	// --- 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: BundledTheme = (process.env.DIFF_THEME as BundledTheme | undefined) ?? "github-dark";
-
-function envInt(name: string, fallback: number): number {
-	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: string, fallback: string): string {
-	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: string, fallback: string): string {
-	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: number, _rowOffset: number): string {
-	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
-
-// ---------------------------------------------------------------------------
-// Theme-aware diff colors
-// ---------------------------------------------------------------------------
-
-/** Resolved ANSI colors for diff rendering — theme overrides hardcoded defaults. */
-interface DiffColors {
-	fgAdd: string;
-	fgDel: string;
-	fgCtx: string;
-}
-
-let DEFAULT_DIFF_COLORS: DiffColors = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
-
-/** 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?: any): DiffColors {
-	// 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?: number): number {
-	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;
-}
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-interface DiffLine {
-	type: "add" | "del" | "ctx" | "sep";
-	oldNum: number | null;
-	newNum: number | null;
-	content: string;
-}
-
-interface ParsedDiff {
-	lines: DiffLine[];
-	added: number;
-	removed: number;
-	chars: number;
-}
-
-// ---------------------------------------------------------------------------
-// Utilities
-// ---------------------------------------------------------------------------
-
-function strip(s: string): string {
-	return s.replace(ANSI_RE, "");
-}
-
-function tabs(s: string): string {
-	return s.replace(/\t/g, "  ");
-}
-
-function termW(): number {
-	// Try multiple sources — process.stdout.columns may be undefined in piped/subagent contexts
-	const raw =
-		process.stdout.columns ||
-		(process.stderr as any).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: string, w: number): string {
-	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: string): string {
-	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: string): boolean {
-	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: string): string {
-	return ansi.replace(ANSI_PARAM_CAPTURE_RE, (seq, params: string) =>
-		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: string, w: number, maxRows = adaptiveWrapRows(), fillBg = ""): string[] {
-	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: string[] = [];
-	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: number | null, w: number, fg = FG_LNUM): string {
-	if (n === null) return " ".repeat(w);
-	const v = String(n);
-	return `${fg}${" ".repeat(Math.max(0, w - v.length))}${v}${RST}`;
-}
-
-function shortPath(cwd: string, home: string, p: string): string {
-	if (!p) return "";
-	const r = relative(cwd, p);
-	if (!r.startsWith("..") && !r.startsWith("/")) return r;
-	return p.replace(home, "~");
-}
-
-function summarize(a: number, d: number): string {
-	const p: string[] = [];
-	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: number): string {
-	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: ParsedDiff, tw: number, maxRows = MAX_PREVIEW_LINES): boolean {
-	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: Record<string, BundledLanguage> = {
-	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: string): BundledLanguage | undefined {
-	return EXT_LANG[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.
-codeToANSI("", "typescript", THEME).catch(() => {});
-
-const _cache = new Map<string, string[]>();
-
-function _touch(k: string, v: string[]): string[] {
-	_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: string, language: BundledLanguage | undefined): Promise<string[]> {
-	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 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");
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Diff parsing
-// ---------------------------------------------------------------------------
-
-function parseDiff(oldContent: string, newContent: string, ctx = 3): ParsedDiff {
-	const patch = Diff.structuredPatch("", "", oldContent, newContent, "", "", { context: ctx });
-	const lines: DiffLine[] = [];
-	let added = 0,
-		removed = 0;
-
-	for (let hi = 0; hi < patch.hunks.length; hi++) {
-		if (hi > 0) {
-			const prev = patch.hunks[hi - 1];
-			const gap = patch.hunks[hi].oldStart - (prev.oldStart + prev.oldLines);
-			lines.push({ type: "sep", oldNum: null, newNum: gap > 0 ? gap : null, content: "" });
-		}
-		const h = patch.hunks[hi];
-		let oL = h.oldStart,
-			nL = h.newStart;
-		for (const raw of h.lines) {
-			if (raw === "\") continue;
-			const ch = raw[0],
-				text = raw.slice(1);
-			if (ch === "+") {
-				lines.push({ type: "add", oldNum: null, newNum: nL++, content: text });
-				added++;
-			} else if (ch === "-") {
-				lines.push({ type: "del", oldNum: oL++, newNum: null, content: text });
-				removed++;
-			} else {
-				lines.push({ type: "ctx", oldNum: oL++, newNum: nL++, content: text });
-			}
-		}
-	}
-	return { lines, added, removed, chars: oldContent.length + newContent.length };
-}
-
-// ---------------------------------------------------------------------------
-// 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: string,
-	b: string,
-): {
-	similarity: number;
-	oldRanges: Array<[number, number]>;
-	newRanges: Array<[number, number]>;
-} {
-	if (!a && !b) return { similarity: 1, oldRanges: [], newRanges: [] };
-	const parts = Diff.diffWords(a, b);
-	const oldRanges: Array<[number, number]> = [];
-	const newRanges: Array<[number, number]> = [];
-	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: string, ranges: Array<[number, number]>, baseBg: string, hlBg: string): string {
-	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: string, newText: string): { old: string; new: string } {
-	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: ParsedDiff,
-	language: BundledLanguage | undefined,
-	max = MAX_RENDER_LINES,
-	dc: DiffColors = DEFAULT_DIFF_COLORS,
-): Promise<string> {
-	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: string[] = [],
-		newSrc: string[] = [];
-	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: string[] = [];
-	out.push(rule(tw));
-
-	/** Emit a single stacked row with compact gutter + left border bar. */
-	function emitRow(
-		num: number | null,
-		sign: string,
-		gutterBg: string,
-		signFg: string,
-		body: string,
-		bodyBg = "",
-	): void {
-		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: Array<{ l: DiffLine; hl: string }> = [];
-		while (idx < vis.length && vis[idx].type === "del") {
-			dels.push({ l: vis[idx], hl: oldHL[oI] ?? vis[idx].content });
-			oI++;
-			idx++;
-		}
-		const adds: Array<{ l: DiffLine; hl: string }> = [];
-		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: ParsedDiff,
-	language: BundledLanguage | undefined,
-	max = MAX_PREVIEW_LINES,
-	dc: DiffColors = DEFAULT_DIFF_COLORS,
-): Promise<string> {
-	const tw = termW();
-	if (!shouldUseSplit(diff, tw, max)) return renderUnified(diff, language, max, dc);
-	if (!diff.lines.length) return "";
-
-	// Build rows
-	type Row = { left: DiffLine | null; right: DiffLine | null };
-	const rows: Row[] = [];
-	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: DiffLine[] = [],
-			adds: DiffLine[] = [];
-		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: string[] = [],
-		rightSrc: string[] = [];
-	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
-
-	// Returns { gutter, contGutter, body } for wrapping composition
-	type HalfResult = { gutter: string; contGutter: string; bodyRows: string[] };
-
-	function half_build(
-		line: DiffLine | null,
-		hl: string,
-		ranges: Array<[number, number]> | null,
-		side: "left" | "right",
-	): HalfResult {
-		// 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: string;
-		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: string[] = [];
-	// 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: HalfResult, rResult: HalfResult;
-
-		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
-// ---------------------------------------------------------------------------
-
-export const __testing = {
-	normalizeShikiContrast,
-	parseDiff,
-	renderSplit,
-	renderUnified,
-};
-
-export default function diffRendererExtension(pi: any): void {
-	// Apply diff theme palette from settings/presets before rendering
-	applyDiffPalette();
-
-	let createWriteTool: any, createEditTool: any, TextComponent: any;
-	try {
-		const sdk = require("@mariozechner/pi-coding-agent");
-		createWriteTool = sdk.createWriteTool;
-		createEditTool = sdk.createEditTool;
-		TextComponent = require("@mariozechner/pi-tui").Text;
-	} catch {
-		return;
-	}
-	if (!createWriteTool || !createEditTool || !TextComponent) return;
-
-	const cwd = process.cwd();
-	const home = process.env.HOME ?? "";
-	const sp = (p: string) => shortPath(cwd, home, p);
-
-	// =======================================================================
-	// write
-	// =======================================================================
-
-	const origWrite = createWriteTool(cwd);
-
-	pi.registerTool({
-		...origWrite,
-		name: "write",
-
-		async execute(tid: string, params: any, sig: any, upd: any, ctx: any) {
-			const fp = params.path ?? params.file_path ?? "";
-			let old: string | null = null;
-			try {
-				if (fp && existsSync(fp)) old = 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 = parseDiff(old, content);
-				const lg = lang(fp);
-				(result as any).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 as any).details = { _type: "new", lines: lineCount, content: content ?? "", filePath: fp };
-			} else if (old === content) {
-				(result as any).details = { _type: "noChange" };
-			}
-			return result;
-		},
-
-		renderCall(args: any, theme: any, ctx: any) {
-			const fp = args?.path ?? args?.file_path ?? "";
-			const isNew = !fp || !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:${fp}:${String(args.content).length}`;
-				if (ctx.state._previewKey !== previewKey) {
-					ctx.state._previewKey = previewKey;
-					ctx.state._previewText = hdr;
-					const lg = lang(fp);
-					hlBlock(args.content, lg)
-						.then((lines: string[]) => {
-							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: any, _opt: any, theme: any, ctx: any) {
-			const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
-			if (ctx.isError) {
-				const e =
-					result.content
-						?.filter((c: any) => c.type === "text")
-						.map((c: any) => 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:${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 = resolveDiffColors(theme);
-					renderSplit(d.diff, d.language, MAX_RENDER_LINES, dc)
-						.then((rendered: string) => {
-							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:${fp}:${lineCount}`;
-				if (ctx.state._nfk !== pk) {
-					ctx.state._nfk = pk;
-					ctx.state._nft = `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}`;
-					const lg = lang(fp);
-					if (rawContent) {
-						hlBlock(rawContent, lg)
-							.then((hlLines: string[]) => {
-								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: any): Array<{ oldText: string; newText: string }> {
-		if (Array.isArray(input?.edits)) {
-			return input.edits
-				.map((edit: any) => ({
-					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: { oldText: string; newText: string }) => 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: Array<{ oldText: string; newText: string }>) {
-		const diffs = operations.map((edit) => 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: string, params: any, sig: any, upd: any, ctx: any) {
-			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 && existsSync(fp)) {
-						const f = 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 as any).details = { _type: "editInfo", summary, editLine };
-				return result;
-			}
-
-			(result as any).details = {
-				_type: "multiEditInfo",
-				summary,
-				editCount: operations.length,
-				diffLineCount: diffs.reduce((sum, diff) => sum + diff.lines.length, 0),
-			};
-			return result;
-		},
-
-		renderCall(args: any, theme: any, ctx: any) {
-			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, w: termW() });
-			if (ctx.state._pk !== pk) {
-				ctx.state._pk = pk;
-				ctx.state._pt = `${hdr}  ${theme.fg("muted", "(rendering…)")}`;
-				const lg = lang(fp);
-				const dc = resolveDiffColors(theme);
-
-				if (operations.length === 1) {
-					const diff = parseDiff(operations[0].oldText, operations[0].newText);
-					renderSplit(diff, lg, MAX_PREVIEW_LINES, dc)
-						.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) =>
-							renderSplit(diff, lg, previewLines, dc)
-								.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: any, _opt: any, theme: any, ctx: any) {
-			const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
-			if (ctx.isError) {
-				const e =
-					result.content
-						?.filter((c: any) => c.type === "text")
-						.map((c: any) => 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;
-		},
-	});
-}