@pi-archimedes/diff 0.5.0 → 0.7.0

package/src/render/unified.ts

@@ -0,0 +1,159 @@
+/** Unified diff view rendering. */
+
+import type { BundledLanguage } from "shiki";
+import * as Ansi from "../ansi/index.js";
+import type { DiffBg, DiffColors } from "../ansi/index.js";
+import { DEFAULT_DIFF_COLORS, DEFAULT_DIFF_BG } from "../ansi/index.js";
+import { hlBlock } from "../shiki.js";
+import { wordDiffAnalysis, injectBg, plainWordDiff } from "../word-diff.js";
+import type { DiffLine, ParsedDiff } from "../core/diff.js";
+import {
+	MAX_HL_CHARS,
+	MAX_RENDER_LINES,
+	WORD_DIFF_MIN_SIM,
+	DEFAULT_TERM_WIDTH,
+	adaptiveWrapRows,
+	wrapAnsi,
+} from "./shared.js";
+
+// ---------------------------------------------------------------------------
+// Unified view
+// ---------------------------------------------------------------------------
+
+/**
+ * Backward-compatible wrapper — reads width from stdout, returns joined string.
+ * Prefer `renderUnifiedLines` for Component-based rendering.
+ */
+export async function renderUnified(
+	diff: ParsedDiff,
+	language: BundledLanguage | undefined,
+	max = MAX_RENDER_LINES,
+	dc: DiffColors = DEFAULT_DIFF_COLORS,
+): Promise<string> {
+	const width = process.stdout.columns ?? DEFAULT_TERM_WIDTH;
+	// Build DiffBg from current (possibly theme-derived) global aliases.
+	const dbg: DiffBg = {
+		bgAdd: Ansi.BG_ADD,
+		bgDel: Ansi.BG_DEL,
+		bgAddW: Ansi.BG_ADD_W,
+		bgDelW: Ansi.BG_DEL_W,
+		bgGutterAdd: Ansi.BG_GUTTER_ADD,
+		bgGutterDel: Ansi.BG_GUTTER_DEL,
+		bgEmpty: Ansi.BG_EMPTY,
+		bgBase: Ansi.BG_BASE,
+		rst: Ansi.BG_BASE === "\x1b[49m" ? "\x1b[0m" : `\x1b[0m${Ansi.BG_BASE}`,
+		divider: Ansi.DIVIDER,
+	};
+	const lines = await renderUnifiedLines(diff, language, width, max, dc, dbg);
+	return lines.join("\n");
+}
+
+export async function renderUnifiedLines(
+	diff: ParsedDiff,
+	language: BundledLanguage | undefined,
+	width: number,
+	max = MAX_RENDER_LINES,
+	dc: DiffColors = DEFAULT_DIFF_COLORS,
+	dbg: DiffBg = DEFAULT_DIFF_BG,
+): Promise<string[]> {
+	if (!diff.lines.length) return [];
+
+	const vis = diff.lines.slice(0, max);
+	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, width - gw);
+	const canHL = diff.chars <= MAX_HL_CHARS && vis.length <= MAX_RENDER_LINES;
+	const rst = dbg.rst;
+	const bgBase = dbg.bgBase;
+
+	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(dbg, width));
+
+	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}${rst}` : `${bgBase} `;
+		const numFg = borderFg || Ansi.FG_LNUM;
+		const gutter = `${border}${gutterBg}${Ansi.lnum(num, nw, numFg)}${signFg}${sign}${rst} ${dbg.divider} `;
+		const contGutter = `${border}${gutterBg}${" ".repeat(nw + 1)}${rst} ${dbg.divider} `;
+		const rows = wrapAnsi(Ansi.tabs(body), cw, adaptiveWrapRows(cw), bodyBg, rst);
+		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]!;
+
+		if (l.type === "sep") {
+			const gap = l.newNum;
+			const label = gap && gap > 0 ? ` ${gap} unmodified lines ` : "···";
+			const totalW = Math.min(width, 72);
+			const pad = Math.max(0, totalW - label.length - 2);
+			const half1 = Math.floor(pad / 2), half2 = pad - half1;
+			out.push(`${bgBase}${Ansi.FG_DIM}${"─".repeat(half1)}${label}${"─".repeat(half2)}${rst}`);
+			idx++;
+			continue;
+		}
+
+		if (l.type === "ctx") {
+			const hl = oldHL[oI] ?? l.content;
+			emitRow(l.newNum, " ", bgBase, dc.fgCtx, `${bgBase}${Ansi.DIM}${hl}`, bgBase);
+			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, dbg.bgDel, dbg.bgDelW);
+			const addBody = injectBg(adds[0]!.hl, wd.newRanges, dbg.bgAdd, dbg.bgAddW);
+			emitRow(dels[0]!.l.oldNum, "-", dbg.bgGutterDel, `${dc.fgDel}${Ansi.BOLD}`, delBody, dbg.bgDel);
+			emitRow(adds[0]!.l.newNum, "+", dbg.bgGutterAdd, `${dc.fgAdd}${Ansi.BOLD}`, addBody, dbg.bgAdd);
+			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, "-", dbg.bgGutterDel, `${dc.fgDel}${Ansi.BOLD}`, `${dbg.bgDel}${pwd.old}`, dbg.bgDel);
+			emitRow(adds[0]!.l.newNum, "+", dbg.bgGutterAdd, `${dc.fgAdd}${Ansi.BOLD}`, `${dbg.bgAdd}${pwd.new}`, dbg.bgAdd);
+			continue;
+		}
+
+		for (const d of dels) {
+			const body = canHL ? `${dbg.bgDel}${d.hl}` : `${dbg.bgDel}${d.l.content}`;
+			emitRow(d.l.oldNum, "-", dbg.bgGutterDel, `${dc.fgDel}${Ansi.BOLD}`, body, dbg.bgDel);
+		}
+		for (const a of adds) {
+			const body = canHL ? `${dbg.bgAdd}${a.hl}` : `${dbg.bgAdd}${a.l.content}`;
+			emitRow(a.l.newNum, "+", dbg.bgGutterAdd, `${dc.fgAdd}${Ansi.BOLD}`, body, dbg.bgAdd);
+		}
+	}
+
+	out.push(Ansi.rule(dbg, width));
+	if (diff.lines.length > vis.length) {
+		out.push(`${bgBase}${Ansi.FG_DIM}  … ${diff.lines.length - vis.length} more lines${rst}`);
+	}
+	return out;
+}

package/src/shiki.ts

@@ -4,7 +4,7 @@ import { extname } from "node:path";
 import { codeToANSI } from "@shikijs/cli";
 import type { BundledLanguage, BundledTheme } from "shiki";
 
-import { normalizeShikiContrast } from "./ansi.js";
+import { normalizeShikiContrast } from "./ansi/index.js";
 
 // ---------------------------------------------------------------------------
 // Config access

package/src/tools/edit.ts

@@ -0,0 +1,170 @@
+/** Edit tool override with diff rendering. */
+
+import { existsSync, readFileSync } from "node:fs";
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import { Box, Spacer, Text } from "@earendil-works/pi-tui";
+import { parseDiff } from "../core/diff.js";
+import * as Ansi from "../ansi/index.js";
+import { themeCacheKey } from "../ansi/index.js";
+import { lang } from "../shiki.js";
+import { MAX_PREVIEW_LINES } from "../render/index.js";
+import { DiffComponent } from "../diff-component.js";
+
+/** Register the edit tool override. */
+export function registerEditTool(
+	pi: ExtensionAPI,
+	cwd: string,
+	home: string,
+	createEditTool: (cwd: string) => any,
+): void {
+	const sp = (p: string) => Ansi.shortPath(cwd, home, p);
+	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",
+		renderShell: "self",
+
+		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);
+
+			// Box with padding + background — matches built-in edit tool pattern
+			const box = ctx.state.callBox as Box | undefined;
+			if (box) {
+				box.setBgFn((s: string) => theme.bg("toolPendingBg", s));
+			}
+			const shell = box ?? new Box(1, 1, (s: string) => theme.bg("toolPendingBg", s));
+			if (!box) ctx.state.callBox = shell;
+
+			const hdr = `${theme.fg("toolTitle", theme.bold("edit"))} ${theme.fg("accent", sp(fp))}`;
+
+			if (!(ctx.argsComplete && operations.length > 0)) {
+				shell.clear();
+				shell.addChild(new Text(hdr, 0, 0));
+				return shell;
+			}
+
+			const pk = JSON.stringify({ fp, operations, theme: themeCacheKey(theme) });
+			if (ctx.state._pk === pk && shell.children.length > 1) {
+				return shell;
+			}
+			ctx.state._pk = pk;
+
+			shell.clear();
+			shell.addChild(new Text(hdr, 0, 0));
+
+			const lg = lang(fp);
+			const { diffs } = summarizeEditOperations(operations);
+
+			if (operations.length === 1) {
+				const diff = diffs[0];
+				if (diff) {
+					shell.addChild(new Spacer(1));
+					shell.addChild(new DiffComponent(diff, lg, theme, MAX_PREVIEW_LINES));
+				}
+			} else {
+				const maxShown = Math.min(operations.length, 3);
+				const previewLines = Math.max(8, Math.floor(MAX_PREVIEW_LINES / maxShown));
+				for (let i = 0; i < maxShown && i < diffs.length; i++) {
+					const diff = diffs[i];
+					if (!diff) continue;
+					if (i > 0) shell.addChild(new Spacer(1));
+					shell.addChild(new Text(
+						theme.fg("muted", `Edit ${i + 1}/${operations.length}`),
+						0, 0,
+					));
+					shell.addChild(new DiffComponent(diff, lg, theme, previewLines));
+				}
+				const remainder = operations.length - maxShown;
+				if (remainder > 0) {
+					shell.addChild(new Spacer(1));
+					shell.addChild(new Text(
+						`  ${theme.fg("dim", `… ${remainder} more edit blocks`)}`,
+						0, 0,
+					));
+				}
+			}
+
+			return shell;
+		},
+
+		renderResult(result: any, _opt: any, theme: any, ctx: any) {
+			// Update the call Box background to reflect final state.
+			const box = ctx.state.callBox as Box | undefined;
+			if (box) {
+				const bgKey = ctx.isError ? "toolErrorBg" : "toolSuccessBg";
+				box.setBgFn((s: string) => theme.bg(bgKey, s));
+			}
+			// Show summary below the diff
+			if (ctx.isError) {
+				const e = result.content
+					?.filter((c: any) => c.type === "text")
+					.map((c: any) => c.text || "")
+					.join("\n") ?? "Error";
+				return new Text(`\n${theme.fg("error", e)}`, 1, 0);
+			}
+			if (result.details?._type === "editInfo") {
+				const { summary: s, editLine } = result.details;
+				const loc = editLine > 0 ? ` ${theme.fg("muted", `at line ${editLine}`)}` : "";
+				return new Text(`  ${s}${loc}`, 1, 0);
+			}
+			if (result.details?._type === "multiEditInfo") {
+				const { summary: s, editCount, diffLineCount } = result.details;
+				return new Text(`  ${editCount} edits ${s}${typeof diffLineCount === "number" ? ` ${theme.fg("muted", `(${diffLineCount} diff lines)`)}` : ""}`, 1, 0);
+			}
+			return new Text("", 0, 0);
+		},
+	});
+}

package/src/tools/index.ts

@@ -0,0 +1,4 @@
+/** Tool registration — barrel re-export. */
+
+export { registerWriteTool } from "./write.js";
+export { registerEditTool } from "./edit.js";

package/src/tools/write.ts

@@ -0,0 +1,148 @@
+/** Write tool override with diff rendering. */
+
+import { existsSync, readFileSync } from "node:fs";
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { parseDiff } from "../core/diff.js";
+import * as Ansi from "../ansi/index.js";
+import { themeCacheKey } from "../ansi/index.js";
+import { lang, hlBlock } from "../shiki.js";
+import { DiffComponent } from "../diff-component.js";
+import { MAX_RENDER_LINES } from "../render/index.js";
+
+/** Register the write tool override. */
+export function registerWriteTool(
+	pi: ExtensionAPI,
+	cwd: string,
+	home: string,
+	createWriteTool: (cwd: string) => any,
+	TextComponent: new (text?: string, paddingX?: number, paddingY?: number) => Component,
+): void {
+	const sp = (p: string) => Ansi.shortPath(cwd, home, p);
+	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 comp = ctx.lastComponent instanceof DiffComponent
+					? ctx.lastComponent
+					: new DiffComponent(d.diff, d.language, theme, MAX_RENDER_LINES);
+				return comp;
+			}
+			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;
+		},
+	});
+}

package/src/word-diff.ts

@@ -1,7 +1,7 @@
 /** Word diff analysis and background injection. */
 
 import * as Diff from "diff";
-import * as Ansi from "./ansi.js";
+import * as Ansi from "./ansi/index.js";
 
 // ---------------------------------------------------------------------------
 // Word diff analysis