@pi-archimedes/diff 0.2.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pi-archimedes/diff",
+  "version": "0.2.0",
+  "type": "module",
+  "keywords": [
+    "pi-package"
+  ],
+  "description": "Shiki-powered diff rendering for pi-archimedes",
+  "files": [
+    "src"
+  ],
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "diff": "^8.0.0",
+    "shiki": "^4.0.0",
+    "@shikijs/cli": "^4.0.2"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.1.0",
+    "@earendil-works/pi-tui": ">=0.1.0"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "typescript": "^6.0.0"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/src/ansi.ts

@@ -0,0 +1,262 @@
+/** ANSI constants and text manipulation utilities. */
+
+import { relative } from "node:path";
+
+// ---------------------------------------------------------------------------
+// ANSI escape codes
+// ---------------------------------------------------------------------------
+
+export let RST = "\x1b[0m";
+export const BOLD = "\x1b[1m";
+export const DIM = "\x1b[2m";
+
+// Diff foregrounds
+export const FG_ADD = "\x1b[38;2;100;180;120m"; // desaturated green
+export const FG_DEL = "\x1b[38;2;200;100;100m"; // desaturated red
+export const FG_DIM = "\x1b[38;2;80;80;80m";
+export const FG_LNUM = "\x1b[38;2;100;100;100m";
+export const FG_RULE = "\x1b[38;2;50;50;50m";
+export const FG_SAFE_MUTED = "\x1b[38;2;139;148;158m";
+export const FG_STRIPE = "\x1b[38;2;40;40;40m"; // gray diagonal stripes
+
+// Diff backgrounds — muted tones to let syntax fg shine through
+export let BG_ADD = "\x1b[48;2;22;38;32m"; // muted teal-green
+export let BG_DEL = "\x1b[48;2;45;25;25m"; // muted brown-red
+export let BG_ADD_W = "\x1b[48;2;35;75;50m"; // word-level emphasis
+export let BG_DEL_W = "\x1b[48;2;80;35;35m";
+export let BG_GUTTER_ADD = "\x1b[48;2;18;32;26m";
+export let BG_GUTTER_DEL = "\x1b[48;2;38;22;22m";
+export const BG_GUTTER_CTX = ""; // use terminal default bg for context gutters
+export let BG_EMPTY = "\x1b[48;2;18;18;18m"; // filler rows
+
+export const BORDER_BAR = "▌";
+
+export let DIVIDER = `${FG_RULE}│${RST}`;
+const ESC_RE = "\u001b";
+export 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
+export let BG_BASE = BG_DEFAULT; // tool box base bg — updated from theme's toolSuccessBg
+
+// ---------------------------------------------------------------------------
+// ANSI manipulation
+// ---------------------------------------------------------------------------
+
+const stripSgr = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "");
+
+/** Strip all ANSI escape codes from a string. */
+export const strip = stripSgr;
+
+/** Replace tabs with 2 spaces. */
+export function tabs(s: string): string {
+	return s.replace(/\t/g, "  ");
+}
+
+/** Pad/truncate `s` to exactly `w` visible chars. ANSI-aware. */
+export 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);
+	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. */
+export 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;
+}
+
+/** Check if a Shiki fg code is too dark to read. */
+export 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;
+}
+
+/** Normalize Shiki ANSI output to boost low-contrast fg codes. */
+export function normalizeShikiContrast(ansi: string): string {
+	return ansi.replace(ANSI_PARAM_CAPTURE_RE, (seq, params: string) =>
+		isLowContrastShikiFg(params) ? FG_SAFE_MUTED : seq,
+	);
+}
+
+/** Generate a dense diagonal stripe fill for empty filler cells. */
+export function stripes(w: number, _rowOffset: number): string {
+	return BG_BASE + FG_STRIPE + "╱".repeat(w) + RST;
+}
+
+/** Format a line number, right-padded to width `w`. */
+export 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}`;
+}
+
+/** Horizontal rule line. */
+export function rule(w: number): string {
+	return `${BG_BASE}${FG_RULE}${"─".repeat(w)}${RST}`;
+}
+
+/** Shorten a file path relative to cwd or home. */
+export 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, "~");
+}
+
+/** Summarize added/removed counts as colored `+N -M` string. */
+export 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}`;
+}
+
+// ---------------------------------------------------------------------------
+// Diff color system — auto-derive from theme, hardcoded fallback
+// ---------------------------------------------------------------------------
+
+/** 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;
+}
+
+/** Mix an accent color into a base color at the given intensity (0.0–1.0). */
+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`;
+}
+
+/** Auto-derive all diff background colors from the pi theme's fg diff colors. */
+export 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 */ }
+
+			try {
+				const errorParsed = parseAnsiRgb(theme.getBgAnsi("toolErrorBg"));
+				if (errorParsed) delBase = errorParsed;
+			} catch { /* no toolErrorBg */ }
+		}
+
+		BG_ADD = mixBg(addBase, addRgb, 0.08);
+		BG_DEL = mixBg(delBase, delRgb, 0.1);
+		BG_ADD_W = mixBg(addBase, addRgb, 0.2);
+		BG_DEL_W = mixBg(delBase, delRgb, 0.22);
+		BG_GUTTER_ADD = mixBg(addBase, addRgb, 0.05);
+		BG_GUTTER_DEL = mixBg(delBase, delRgb, 0.06);
+		BG_EMPTY = BG_BASE;
+		RST = `\x1b[0m${BG_BASE}`;
+		DIVIDER = `${FG_RULE}│${RST}`;
+	} catch {
+		// Fall back to defaults silently
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Theme-aware diff colors
+// ---------------------------------------------------------------------------
+
+export interface DiffColors {
+	fgAdd: string;
+	fgDel: string;
+	fgCtx: string;
+}
+
+export const DEFAULT_DIFF_COLORS: DiffColors = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
+
+export function themeCacheKey(theme?: any): string {
+	if (!theme?.fg) return "no-theme";
+	const fgKeys = [
+		"toolTitle", "accent", "muted", "success", "error",
+		"toolDiffAdded", "toolDiffRemoved", "toolDiffContext",
+	];
+	const bgKeys = ["toolSuccessBg", "toolErrorBg"];
+	const parts: string[] = [];
+	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("|");
+}
+
+let _didAutoDerive = false;
+export function resolveDiffColors(theme?: any): DiffColors {
+	if (!_didAutoDerive && theme?.getFgAnsi) {
+		autoDeriveBgFromTheme(theme);
+		_didAutoDerive = true;
+	}
+	if (!theme?.getFgAnsi) return DEFAULT_DIFF_COLORS;
+	try {
+		return {
+			fgAdd: theme.getFgAnsi("toolDiffAdded") || FG_ADD,
+			fgDel: theme.getFgAnsi("toolDiffRemoved") || FG_DEL,
+			fgCtx: theme.getFgAnsi("toolDiffContext") || FG_DIM,
+		};
+	} catch {
+		return DEFAULT_DIFF_COLORS;
+	}
+}

package/src/core/diff.ts

@@ -0,0 +1,48 @@
+import * as Diff from "diff";
+
+export interface DiffLine {
+	type: "add" | "del" | "ctx" | "sep";
+	oldNum: number | null;
+	newNum: number | null;
+	content: string;
+}
+
+export interface ParsedDiff {
+	lines: DiffLine[];
+	added: number;
+	removed: number;
+	chars: number;
+}
+
+export function parseDiff(oldContent: string, newContent: string, ctx = 3): ParsedDiff {
+	const patch = Diff.structuredPatch("", "", oldContent, newContent, "", "", { context: ctx });
+	const lines: DiffLine[] = [];
+	let added = 0;
+	let 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;
+		let nL = h.newStart;
+		for (const raw of h.lines) {
+			if (raw === "\") continue;
+			const ch = raw[0];
+			const 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 };
+}

package/src/index.ts

@@ -0,0 +1,409 @@
+/**
+ * @pi-archimedes/diff — Shiki-powered terminal diff rendering.
+ *
+ * Adapted from pi-ui-hephaestus diff renderer.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import type { SettingItem } from "@earendil-works/pi-tui";
+
+import { type DiffLine, type ParsedDiff, parseDiff } from "./core/diff.js";
+import * as Ansi from "./ansi.js";
+import { resolveDiffColors, themeCacheKey, DEFAULT_DIFF_COLORS } from "./ansi.js";
+import { setConfigGetter as setShikiConfig } from "./shiki.js";
+import { hlBlock, lang } from "./shiki.js";
+import { renderSplit } from "./render.js";
+import { setConfigGetter as setRenderConfig } from "./render.js";
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+export interface DiffConfig {
+	diffTheme: string;
+	diffSplitMinWidth: number;
+	diffSplitMinCodeWidth: number;
+}
+
+const DEFAULT_DIFF_CONFIG: DiffConfig = {
+	diffTheme: "github-dark",
+	diffSplitMinWidth: 150,
+	diffSplitMinCodeWidth: 60,
+};
+
+let _readConfig: () => DiffConfig = () => DEFAULT_DIFF_CONFIG;
+function getConfig(): DiffConfig { return _readConfig(); }
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MAX_PREVIEW_LINES = 60;
+const MAX_RENDER_LINES = 150;
+
+// ---------------------------------------------------------------------------
+// Settings
+// ---------------------------------------------------------------------------
+
+export function getDiffSettingsItems(): SettingItem[] {
+	const config = getConfig();
+	return [
+		{
+			id: "diffTheme",
+			label: "Diff Theme",
+			description: "Shiki theme for diff syntax highlighting",
+			currentValue: config.diffTheme,
+		},
+		{
+			id: "diffSplitMinWidth",
+			label: "Split Min Width",
+			description: "Minimum terminal width for split diff view",
+			currentValue: String(config.diffSplitMinWidth),
+		},
+		{
+			id: "diffSplitMinCodeWidth",
+			label: "Split Min Code Width",
+			description: "Minimum code column width for split diff view",
+			currentValue: String(config.diffSplitMinCodeWidth),
+		},
+	];
+}
+
+// ---------------------------------------------------------------------------
+// Extension entry point
+// ---------------------------------------------------------------------------
+
+export function registerDiffTools(
+	pi: ExtensionAPI,
+	_getTheme: () => Theme,
+	readConfig: () => DiffConfig,
+): void {
+	_readConfig = readConfig;
+
+	// Wire config getters into submodules
+	setShikiConfig(() => getConfig());
+	setRenderConfig(() => getConfig());
+
+	(async () => {
+		let createWriteTool: any, createEditTool: any, TextComponent: any;
+		try {
+			const sdk = await import("@earendil-works/pi-coding-agent");
+			const tui = await import("@earendil-works/pi-tui");
+			createWriteTool = sdk.createWriteTool;
+			createEditTool = sdk.createEditTool;
+			TextComponent = tui.Text;
+		} catch (error) {
+			console.error(
+				`[diff] failed to load Pi SDK: ${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: string) => Ansi.shortPath(cwd, home, p);
+
+		// ===================================================================
+		// write tool
+		// ===================================================================
+
+		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 ?? "";
+
+				if (old !== null && old !== content) {
+					const diff = parseDiff(old, content);
+					const lg = lang(fp);
+					(result as any).details = {
+						_type: "diff",
+						summary: Ansi.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, 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))}`;
+
+				if (args?.content && !ctx.argsComplete) {
+					const n = String(args.content).split("\n").length;
+					text.setText(`${hdr}  ${theme.fg("muted", `(${n} lines…)`)}`);
+					return text;
+				}
+
+				if (args?.content && ctx.argsComplete && isNew) {
+					const previewKey = `create:${themeCacheKey(theme)}:${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 = process.stdout.columns ?? 200;
+					const key = `wd:${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 = 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:${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 = 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 tool
+		// ===================================================================
+
+		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: Ansi.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, theme: themeCacheKey(theme), w: process.stdout.columns ?? 200 });
+				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${Ansi.summarize(diff.added, diff.removed)}\n${rendered}`;
+								ctx.invalidate();
+							})
+							.catch(() => {
+								if (ctx.state._pk !== pk) return;
+								ctx.state._pt = `${hdr}  ${Ansi.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}  ${Ansi.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.ANSI_RE, "").length;
+					const pad = Math.max(0, (process.stdout.columns ?? 200) - 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.ANSI_RE, "").length;
+					const pad = Math.max(0, (process.stdout.columns ?? 200) - vis);
+					text.setText(`${content}${" ".repeat(pad)}`);
+					return text;
+				}
+				text.setText(`  ${theme.fg("dim", String(result?.content?.[0]?.text ?? "edited").slice(0, 120))}`);
+				return text;
+			},
+		});
+	})().catch(console.error);
+}

package/src/render.ts

@@ -0,0 +1,393 @@
+/** Split and unified diff rendering. */
+
+import type { BundledLanguage } from "shiki";
+import * as Ansi from "./ansi.js";
+import type { DiffColors } from "./ansi.js";
+import { DEFAULT_DIFF_COLORS } from "./ansi.js";
+import { hlBlock } from "./shiki.js";
+import { wordDiffAnalysis, injectBg, plainWordDiff } from "./word-diff.js";
+import type { DiffLine, ParsedDiff } from "./core/diff.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MAX_PREVIEW_LINES = 60;
+const MAX_RENDER_LINES = 150;
+const MAX_HL_CHARS = 80_000;
+const WORD_DIFF_MIN_SIM = 0.15;
+const SPLIT_MAX_WRAP_RATIO = 0.2;
+const SPLIT_MAX_WRAP_LINES = 8;
+const MAX_WRAP_ROWS_WIDE = 3;
+const MAX_WRAP_ROWS_MED = 2;
+const MAX_WRAP_ROWS_NARROW = 1;
+const MAX_TERM_WIDTH = 210;
+const DEFAULT_TERM_WIDTH = 200;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+export function getConfig(): { diffSplitMinWidth: number; diffSplitMinCodeWidth: number } {
+	return typeof _getConfig === "function" ? _getConfig() : DEFAULT_CONFIG;
+}
+
+const DEFAULT_CONFIG = { diffSplitMinWidth: 150, diffSplitMinCodeWidth: 60 };
+let _getConfig: (() => { diffSplitMinWidth: number; diffSplitMinCodeWidth: number }) | undefined;
+export function setConfigGetter(fn: () => { diffSplitMinWidth: number; diffSplitMinCodeWidth: number }): void {
+	_getConfig = fn;
+}
+
+function termW(): number {
+	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));
+}
+
+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;
+}
+
+/** Wrap ANSI-encoded string into rows of `w` visible chars. */
+function wrapAnsi(s: string, w: number, maxRows = adaptiveWrapRows(), fillBg = ""): string[] {
+	if (w <= 0) return [""];
+	const plain = Ansi.strip(s);
+	if (plain.length <= w) {
+		const pad = w - plain.length;
+		return pad > 0 ? [s + fillBg + " ".repeat(pad) + (fillBg ? Ansi.RST : "")] : [s];
+	}
+
+	const rows: string[] = [];
+	let row = "", vis = 0, i = 0;
+	let onLastRow = false;
+	let effW = w;
+
+	while (i < s.length) {
+		if (!onLastRow && rows.length >= maxRows - 1) {
+			onLastRow = true;
+			effW = w > 2 ? w - 1 : w;
+		}
+		if (s[i] === "\x1b") {
+			const end = s.indexOf("m", i);
+			if (end !== -1) {
+				row += s.slice(i, end + 1);
+				i = end + 1;
+				continue;
+			}
+		}
+		if (vis >= effW) {
+			if (onLastRow) {
+				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 += `${Ansi.RST}${Ansi.FG_DIM}›${Ansi.RST}`;
+				else row += fillBg + " ".repeat(Math.max(0, w - vis)) + Ansi.RST;
+				rows.push(row);
+				return rows;
+			}
+			const state = Ansi.ansiState(row);
+			rows.push(row + Ansi.RST);
+			row = state + fillBg;
+			vis = 0;
+			if (rows.length >= maxRows - 1) {
+				onLastRow = true;
+				effW = w > 2 ? w - 1 : w;
+			}
+		}
+		row += s[i];
+		vis++;
+		i++;
+	}
+	if (row.length > 0 || rows.length === 0) {
+		rows.push(row + fillBg + " ".repeat(Math.max(0, w - vis)) + Ansi.RST);
+	}
+	return rows;
+}
+
+function shouldUseSplit(diff: ParsedDiff, tw: number, maxRows = MAX_PREVIEW_LINES): boolean {
+	if (!diff.lines.length) return false;
+	const cfg = getConfig();
+	if (tw < cfg.diffSplitMinWidth) 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);
+	const gw = nw + 5;
+	const cw = Math.max(12, half - gw);
+	if (cw < cfg.diffSplitMinCodeWidth) return false;
+
+	const vis = diff.lines.slice(0, maxRows);
+	let contentLines = 0, wrapCandidates = 0;
+	for (const l of vis) {
+		if (l.type === "sep") continue;
+		contentLines++;
+		if (Ansi.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;
+}
+
+// ---------------------------------------------------------------------------
+// Unified view
+// ---------------------------------------------------------------------------
+
+export 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;
+	const cw = Math.max(20, tw - gw);
+	const canHL = diff.chars <= MAX_HL_CHARS && vis.length <= MAX_RENDER_LINES;
+
+	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(Ansi.rule(tw));
+
+	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}${Ansi.BORDER_BAR}${Ansi.RST}` : `${Ansi.BG_BASE} `;
+		const numFg = borderFg || Ansi.FG_LNUM;
+		const gutter = `${border}${gutterBg}${Ansi.lnum(num, nw, numFg)}${signFg}${sign}${Ansi.RST} ${Ansi.DIVIDER} `;
+		const contGutter = `${border}${gutterBg}${" ".repeat(nw + 1)}${Ansi.RST} ${Ansi.DIVIDER} `;
+		const rows = wrapAnsi(Ansi.tabs(body), cw, adaptiveWrapRows(), bodyBg);
+		out.push(`${gutter}${rows[0]}${Ansi.RST}`);
+		for (let r = 1; r < rows.length; r++) out.push(`${contGutter}${rows[r]}${Ansi.RST}`);
+	}
+
+	while (idx < vis.length) {
+		const l = vis[idx];
+
+		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(`${Ansi.BG_BASE}${Ansi.FG_DIM}${"─".repeat(half1)}${label}${"─".repeat(half2)}${Ansi.RST}`);
+			idx++;
+			continue;
+		}
+
+		if (l.type === "ctx") {
+			const hl = oldHL[oI] ?? l.content;
+			emitRow(l.newNum, " ", Ansi.BG_BASE, dc.fgCtx, `${Ansi.BG_BASE}${Ansi.DIM}${hl}`, Ansi.BG_BASE);
+			oI++; nI++; idx++;
+			continue;
+		}
+
+		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++;
+		}
+
+		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, Ansi.BG_DEL, Ansi.BG_DEL_W);
+			const addBody = injectBg(adds[0].hl, wd.newRanges, Ansi.BG_ADD, Ansi.BG_ADD_W);
+			emitRow(dels[0].l.oldNum, "-", Ansi.BG_GUTTER_DEL, `${dc.fgDel}${Ansi.BOLD}`, delBody, Ansi.BG_DEL);
+			emitRow(adds[0].l.newNum, "+", Ansi.BG_GUTTER_ADD, `${dc.fgAdd}${Ansi.BOLD}`, addBody, Ansi.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, "-", Ansi.BG_GUTTER_DEL, `${dc.fgDel}${Ansi.BOLD}`, `${Ansi.BG_DEL}${pwd.old}`, Ansi.BG_DEL);
+			emitRow(adds[0].l.newNum, "+", Ansi.BG_GUTTER_ADD, `${dc.fgAdd}${Ansi.BOLD}`, `${Ansi.BG_ADD}${pwd.new}`, Ansi.BG_ADD);
+			continue;
+		}
+
+		for (const d of dels) {
+			const body = canHL ? `${Ansi.BG_DEL}${d.hl}` : `${Ansi.BG_DEL}${d.l.content}`;
+			emitRow(d.l.oldNum, "-", Ansi.BG_GUTTER_DEL, `${dc.fgDel}${Ansi.BOLD}`, body, Ansi.BG_DEL);
+		}
+		for (const a of adds) {
+			const body = canHL ? `${Ansi.BG_ADD}${a.hl}` : `${Ansi.BG_ADD}${a.l.content}`;
+			emitRow(a.l.newNum, "+", Ansi.BG_GUTTER_ADD, `${dc.fgAdd}${Ansi.BOLD}`, body, Ansi.BG_ADD);
+		}
+	}
+
+	out.push(Ansi.rule(tw));
+	if (diff.lines.length > vis.length) {
+		out.push(`${Ansi.BG_BASE}${Ansi.FG_DIM}  … ${diff.lines.length - vis.length} more lines${Ansi.RST}`);
+	}
+	return out.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Split view
+// ---------------------------------------------------------------------------
+
+export 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 "";
+
+	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);
+	const nw = Math.max(2, String(Math.max(...diff.lines.map((l) => l.oldNum ?? l.newNum ?? 0), 0)).length);
+	const gw = nw + 5;
+	const cw = Math.max(12, half - gw);
+	const canHL = diff.chars <= MAX_HL_CHARS && vis.length * 2 <= MAX_RENDER_LINES * 2;
+
+	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;
+
+	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 {
+		if (!line) {
+			const gw2 = nw + 2;
+			const gPat = Ansi.FG_STRIPE + "╱".repeat(gw2) + Ansi.RST;
+			const g = ` ${gPat}${Ansi.FG_RULE}│${Ansi.RST} `;
+			return { gutter: g, contGutter: g, bodyRows: [Ansi.stripes(cw, stripeRow)] };
+		}
+		if (line.type === "sep") {
+			const gap = line.newNum;
+			const label = gap && gap > 0 ? `··· ${gap} lines ···` : "···";
+			const g = `${Ansi.BG_BASE} ${Ansi.FG_DIM}${Ansi.fit("", nw + 2)}${Ansi.RST}${Ansi.FG_RULE}│${Ansi.RST} `;
+			return { gutter: g, contGutter: g, bodyRows: [`${Ansi.BG_BASE}${Ansi.FG_DIM}${Ansi.fit(label, cw)}${Ansi.RST}`] };
+		}
+
+		const isDel = line.type === "del", isAdd = line.type === "add";
+		const gBg = isDel ? Ansi.BG_GUTTER_DEL : isAdd ? Ansi.BG_GUTTER_ADD : Ansi.BG_BASE;
+		const cBg = isDel ? Ansi.BG_DEL : isAdd ? Ansi.BG_ADD : Ansi.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;
+
+		const borderFg = isDel ? dc.fgDel : isAdd ? dc.fgAdd : "";
+		const border = borderFg ? `${borderFg}${Ansi.BORDER_BAR}${Ansi.RST}` : ` ${Ansi.BG_BASE}`;
+		const numFg = borderFg || Ansi.FG_LNUM;
+
+		let body: string;
+		if (ranges && ranges.length > 0) {
+			body = injectBg(hl, ranges, cBg, isDel ? Ansi.BG_DEL_W : Ansi.BG_ADD_W);
+		} else if (isDel || isAdd) {
+			body = `${cBg}${hl}`;
+		} else {
+			body = `${Ansi.BG_BASE}${Ansi.DIM}${hl}`;
+		}
+
+		const gutter = `${border}${gBg}${Ansi.lnum(num, nw, numFg)}${sFg}${Ansi.BOLD}${sign}${Ansi.RST} ${Ansi.FG_RULE}│${Ansi.RST} `;
+		const contGutter = `${border}${gBg}${" ".repeat(nw + 1)}${Ansi.RST} ${Ansi.FG_RULE}│${Ansi.RST} `;
+		const bodyRows = wrapAnsi(Ansi.tabs(body), cw, adaptiveWrapRows(), cBg);
+		return { gutter, contGutter, bodyRows };
+	}
+
+	const out: string[] = [];
+	const hdrOld = `${Ansi.BG_BASE}${" ".repeat(Math.max(0, nw - 2))}${dc.fgDel}${Ansi.DIM}old${Ansi.RST}`;
+	const hdrNew = `${Ansi.BG_BASE}${" ".repeat(Math.max(0, nw - 2))}${dc.fgAdd}${Ansi.DIM}new${Ansi.RST}`;
+	out.push(`${Ansi.BG_BASE}${hdrOld}${" ".repeat(Math.max(0, half - nw - 1))}${Ansi.FG_RULE}┊${Ansi.RST}${hdrNew}`);
+	out.push(`${Ansi.rule(half)}${Ansi.FG_RULE}┊${Ansi.RST}${Ansi.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");
+		}
+
+		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 ? Ansi.stripes(cw, stripeRow) : `${Ansi.BG_EMPTY}${" ".repeat(cw)}${Ansi.RST}`);
+			const rb = rResult.bodyRows[row] ?? (rightIsEmpty ? Ansi.stripes(cw, stripeRow) : `${Ansi.BG_EMPTY}${" ".repeat(cw)}${Ansi.RST}`);
+			out.push(`${lg}${lb}${Ansi.DIVIDER}${rg}${rb}`);
+			stripeRow++;
+		}
+	}
+
+	out.push(`${Ansi.rule(half)}${Ansi.FG_RULE}┊${Ansi.RST}${Ansi.rule(half)}`);
+	if (rows.length > vis.length) {
+		out.push(`${Ansi.BG_BASE}${Ansi.FG_DIM}  … ${rows.length - vis.length} more lines${Ansi.RST}`);
+	}
+	return out.join("\n");
+}

package/src/shiki.ts

@@ -0,0 +1,83 @@
+/** Shiki syntax highlighting — lazy init, LRU cache, language detection. */
+
+import { extname } from "node:path";
+import { codeToANSI } from "@shikijs/cli";
+import type { BundledLanguage, BundledTheme } from "shiki";
+
+import { normalizeShikiContrast } from "./ansi.js";
+
+// ---------------------------------------------------------------------------
+// Config access
+// ---------------------------------------------------------------------------
+
+let _getConfig: () => { diffTheme: string } = () => ({ diffTheme: "github-dark" });
+export function setConfigGetter(fn: () => { diffTheme: string }): void {
+	_getConfig = fn;
+}
+
+// ---------------------------------------------------------------------------
+// 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",
+};
+
+export function lang(fp: string): BundledLanguage | undefined {
+	return EXT_LANG[extname(fp).slice(1).toLowerCase()];
+}
+
+// ---------------------------------------------------------------------------
+// Shiki cache + lazy init
+// ---------------------------------------------------------------------------
+
+const MAX_HL_CHARS = 80_000;
+const CACHE_LIMIT = 192;
+
+let _shikiReady = false;
+async function ensureShiki(): Promise<void> {
+	if (_shikiReady) return;
+	_shikiReady = true;
+	codeToANSI("", "typescript", _getConfig().diffTheme as BundledTheme).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;
+}
+
+export async function hlBlock(code: string, language: BundledLanguage | undefined): Promise<string[]> {
+	if (!code) return [""];
+	if (!language || code.length > MAX_HL_CHARS) return code.split("\n");
+
+	await ensureShiki();
+
+	const theme = _getConfig().diffTheme;
+	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 as BundledTheme));
+		const out = (ansi.endsWith("\n") ? ansi.slice(0, -1) : ansi).split("\n");
+		return _touch(k, out);
+	} catch {
+		return code.split("\n");
+	}
+}

package/src/word-diff.ts

@@ -0,0 +1,108 @@
+/** Word diff analysis and background injection. */
+
+import * as Diff from "diff";
+import * as Ansi from "./ansi.js";
+
+// ---------------------------------------------------------------------------
+// Word diff analysis
+// ---------------------------------------------------------------------------
+
+/**
+ * Combined word diff analysis — single Diff.diffWords() call returns both
+ * similarity score and character ranges for emphasis highlighting.
+ */
+export 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 };
+}
+
+// ---------------------------------------------------------------------------
+// Background injection
+// ---------------------------------------------------------------------------
+
+/**
+ * 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).
+ */
+export function injectBg(
+	ansiLine: string,
+	ranges: Array<[number, number]>,
+	baseBg: string,
+	hlBg: string,
+): string {
+	if (!ranges.length) return baseBg + ansiLine + Ansi.RST;
+
+	let out = baseBg;
+	let vis = 0;
+	let inHL = false;
+	let ri = 0;
+	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;
+				if (seq === "\x1b[0m") out += inHL ? hlBg : baseBg;
+				i = m + 1;
+				continue;
+			}
+		}
+		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 + Ansi.RST;
+}
+
+/** Simple word diff (no syntax hl) — fallback when Shiki isn't available. */
+export 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 += `${Ansi.BG_DEL_W}${p.value}${Ansi.RST}${Ansi.BG_DEL}`;
+		else if (p.added) n += `${Ansi.BG_ADD_W}${p.value}${Ansi.RST}${Ansi.BG_ADD}`;
+		else {
+			o += p.value;
+			n += p.value;
+		}
+	}
+	return { old: o, new: n };
+}