@pi-archimedes/diff 2.0.1 → 2.1.0

package/README.md

@@ -2,7 +2,9 @@
 
 Shiki-powered diff rendering for the [Pi coding agent](https://github.com/earendil-works/pi).
 
-## Features
+Syntax-highlighted, word-level diffs make reviewing code changes effortless. By rendering clear side-by-side or unified diffs directly in your terminal with themes matched to your environment, code modifications can be inspected at a glance before committing.
+
+## What you get
 
 - **Split and unified views** — side-by-side split diff or traditional unified view, auto-selected based on terminal width
 - **Shiki syntax highlighting** — full syntax highlighting powered by [Shiki](https://shiki.style), with auto-derived theme colors
@@ -18,16 +20,16 @@ Side-by-side diff with syntax highlighting, word-level emphasis on changed chara
 
 ![diff edit](../../docs/images/diff-edit.png)
 
-## Installation
+## Install
 
 ```bash
-pi install @pi-archimedes/diff
+pi install npm:@pi-archimedes/diff
 ```
 
-Or install the full [pi-archimedes](../..) meta package for the integrated experience:
+Or install full meta package:
 
 ```bash
-pi install pi-archimedes
+pi install npm:pi-archimedes
 ```
 
 ## Settings
@@ -43,3 +45,5 @@ Settings are stored in `~/.pi/agent/settings.json` under the `archimedes.diff` n
 ## Integration
 
 When installed via `pi-archimedes` (the meta package), the diff tools are registered with callbacks to the current theme and config, ensuring colors match your active Pi theme. Standalone installs use default dark theme colors.
+
+← Back to [pi-archimedes](../../README.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/diff",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "type": "module",
   "keywords": [
     "pi-package"

package/src/ansi/codes.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import {
+	RST,
+	BOLD,
+	DIM,
+	FG_ADD,
+	FG_DEL,
+	FG_DIM,
+	FG_LNUM,
+	FG_RULE,
+	FG_SAFE_MUTED,
+	FG_STRIPE,
+	BORDER_BAR,
+	ANSI_RE,
+	ANSI_CAPTURE_RE,
+	ANSI_PARAM_CAPTURE_RE,
+	DEFAULT_DIFF_COLORS,
+	DEFAULT_DIFF_BG,
+	themeCacheKey,
+	resolveDiffColors,
+	resetDiffColors,
+} from "./codes.js";
+
+// ── Exported constants ──────────────────────────────────────────────────────
+
+describe("ANSI constants", () => {
+	it("all exported constants are non-empty strings", () => {
+		expect(typeof RST).toBe("string");
+		expect(RST.length).toBeGreaterThan(0);
+		expect(typeof BOLD).toBe("string");
+		expect(BOLD.length).toBeGreaterThan(0);
+		expect(typeof DIM).toBe("string");
+		expect(DIM.length).toBeGreaterThan(0);
+		expect(typeof FG_ADD).toBe("string");
+		expect(FG_ADD.length).toBeGreaterThan(0);
+		expect(typeof FG_DEL).toBe("string");
+		expect(FG_DEL.length).toBeGreaterThan(0);
+		expect(typeof FG_DIM).toBe("string");
+		expect(FG_DIM.length).toBeGreaterThan(0);
+		expect(typeof FG_LNUM).toBe("string");
+		expect(FG_LNUM.length).toBeGreaterThan(0);
+		expect(typeof FG_RULE).toBe("string");
+		expect(FG_RULE.length).toBeGreaterThan(0);
+		expect(typeof FG_SAFE_MUTED).toBe("string");
+		expect(FG_SAFE_MUTED.length).toBeGreaterThan(0);
+		expect(typeof FG_STRIPE).toBe("string");
+		expect(FG_STRIPE.length).toBeGreaterThan(0);
+		expect(typeof BORDER_BAR).toBe("string");
+		expect(BORDER_BAR.length).toBeGreaterThan(0);
+	});
+
+	it("RST is reset escape", () => {
+		expect(RST).toBe("\x1b[0m");
+	});
+
+	it("BOLD is bold escape", () => {
+		expect(BOLD).toBe("\x1b[1m");
+	});
+
+	it("DIM is dim escape", () => {
+		expect(DIM).toBe("\x1b[2m");
+	});
+
+	it("FG_ADD is truecolor green-ish", () => {
+		expect(FG_ADD).toBe("\x1b[38;2;100;180;120m");
+	});
+
+	it("FG_DEL is truecolor red-ish", () => {
+		expect(FG_DEL).toBe("\x1b[38;2;200;100;100m");
+	});
+});
+
+// ── Regex patterns ──────────────────────────────────────────────────────────
+
+describe("ANSI_RE", () => {
+	it("matches standard ANSI escapes", () => {
+		// Use exec on a copy to avoid lastIndex state issues with global flag
+		const re = new RegExp(ANSI_RE.source, "g");
+		expect(re.test("\x1b[0m")).toBe(true);
+		re.lastIndex = 0;
+		expect(re.test("\x1b[31m")).toBe(true);
+		re.lastIndex = 0;
+		expect(re.test("\x1b[38;2;255;128;64m")).toBe(true);
+	});
+
+	it("matches multiple escapes in a string", () => {
+		const matches = "\x1b[31mred\x1b[0m".match(ANSI_RE);
+		expect(matches).toHaveLength(2);
+	});
+
+	it("does not match plain text", () => {
+		expect("hello world".match(ANSI_RE)).toBeNull();
+	});
+});
+
+describe("ANSI_CAPTURE_RE", () => {
+	it("captures parameters between [ and m", () => {
+		// Use exec() for capture groups with global regex
+		const re = new RegExp(ANSI_CAPTURE_RE.source, "g");
+		const match = re.exec("\x1b[38;2;255;128;64m");
+		expect(match).not.toBeNull();
+		expect(match![1]).toBe("38;2;255;128;64");
+	});
+
+	it("captures empty params for reset", () => {
+		const re = new RegExp(ANSI_CAPTURE_RE.source, "g");
+		const match = re.exec("\x1b[0m");
+		expect(match).not.toBeNull();
+		expect(match![1]).toBe("0");
+	});
+});
+
+describe("ANSI_PARAM_CAPTURE_RE", () => {
+	it("captures numeric params", () => {
+		const re = new RegExp(ANSI_PARAM_CAPTURE_RE.source, "g");
+		const match = re.exec("\x1b[38;2;255;128;64m");
+		expect(match).not.toBeNull();
+		expect(match![1]).toBe("38;2;255;128;64");
+	});
+
+	it("captures simple numeric code", () => {
+		const re = new RegExp(ANSI_PARAM_CAPTURE_RE.source, "g");
+		const match = re.exec("\x1b[31m");
+		expect(match).not.toBeNull();
+		expect(match![1]).toBe("31");
+	});
+});
+
+// ── DEFAULT_DIFF_COLORS ─────────────────────────────────────────────────────
+
+describe("DEFAULT_DIFF_COLORS", () => {
+	it("has all required fields", () => {
+		expect(DEFAULT_DIFF_COLORS.fgAdd).toBe(FG_ADD);
+		expect(DEFAULT_DIFF_COLORS.fgDel).toBe(FG_DEL);
+		expect(DEFAULT_DIFF_COLORS.fgCtx).toBe(FG_DIM);
+	});
+});
+
+// ── themeCacheKey ───────────────────────────────────────────────────────────
+
+describe("themeCacheKey", () => {
+	it("returns 'no-theme' for null theme", () => {
+		expect(themeCacheKey(null)).toBe("no-theme");
+	});
+
+	it("returns 'no-theme' for undefined theme", () => {
+		expect(themeCacheKey(undefined)).toBe("no-theme");
+	});
+
+	it("returns 'no-theme' for theme without fg", () => {
+		expect(themeCacheKey({})).toBe("no-theme");
+	});
+
+	it("returns deterministic string for same theme", () => {
+		const theme = {
+			fg: (token: string, fallback: string) => `fg-${token}`,
+			bg: (token: string, fallback: string) => `bg-${token}`,
+		};
+		const key1 = themeCacheKey(theme);
+		const key2 = themeCacheKey(theme);
+		expect(key1).toBe(key2);
+		expect(typeof key1).toBe("string");
+		expect(key1.length).toBeGreaterThan(0);
+	});
+
+	it("property: deterministic — themeCacheKey(a) === themeCacheKey(a)", () => {
+		fc.assert(
+			fc.property(
+				fc.record({
+					fg: fc.constant((t: string, f: string) => `${t}-${f}`),
+					bg: fc.constant((t: string, f: string) => `bg-${t}`),
+				}),
+				(theme) => {
+					const key1 = themeCacheKey(theme);
+					const key2 = themeCacheKey(theme);
+					return key1 === key2;
+				},
+			),
+		);
+	});
+});
+
+// ── resolveDiffColors ───────────────────────────────────────────────────────
+
+describe("resolveDiffColors", () => {
+	it("returns DEFAULT_DIFF_COLORS when no theme", () => {
+		resetDiffColors();
+		const result = resolveDiffColors(undefined);
+		expect(result).toEqual(DEFAULT_DIFF_COLORS);
+	});
+
+	it("returns DEFAULT_DIFF_COLORS when theme lacks getFgAnsi", () => {
+		resetDiffColors();
+		const result = resolveDiffColors({ fg: () => "" });
+		expect(result).toEqual(DEFAULT_DIFF_COLORS);
+	});
+
+	it("returns theme-derived colors when theme has getFgAnsi", () => {
+		resetDiffColors();
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;50;200;50m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;50;50m";
+				if (token === "toolDiffContext") return "\x1b[38;2;100;100;100m";
+				return "";
+			},
+		};
+		const result = resolveDiffColors(theme);
+		expect(result.fgAdd).toBe("\x1b[38;2;50;200;50m");
+		expect(result.fgDel).toBe("\x1b[38;2;200;50;50m");
+		expect(result.fgCtx).toBe("\x1b[38;2;100;100;100m");
+	});
+
+	it("falls back to defaults when getFgAnsi returns empty string", () => {
+		resetDiffColors();
+		const theme = {
+			getFgAnsi: () => "",
+		};
+		const result = resolveDiffColors(theme);
+		expect(result.fgAdd).toBe(FG_ADD);
+		expect(result.fgDel).toBe(FG_DEL);
+		expect(result.fgCtx).toBe(FG_DIM);
+	});
+});
+
+// ── resetDiffColors ─────────────────────────────────────────────────────────
+
+describe("resetDiffColors", () => {
+	it("clears cache so subsequent call re-derives", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;50;200;50m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;50;50m";
+				if (token === "toolDiffContext") return "\x1b[38;2;100;100;100m";
+				return "";
+			},
+		};
+
+		// First call derives colors
+		const result1 = resolveDiffColors(theme);
+		expect(result1.fgAdd).toBe("\x1b[38;2;50;200;50m");
+
+		// Reset clears cache
+		resetDiffColors();
+
+		// Now change the theme
+		const newTheme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;10;100;10m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;100;10;10m";
+				if (token === "toolDiffContext") return "\x1b[38;2;50;50;50m";
+				return "";
+			},
+		};
+
+		// After reset, new theme should be picked up
+		const result2 = resolveDiffColors(newTheme);
+		expect(result2.fgAdd).toBe("\x1b[38;2;10;100;10m");
+	});
+});

package/src/ansi/colors.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { deriveBgFromTheme } from "./colors.js";
+import { DEFAULT_DIFF_BG, FG_RULE } from "./codes.js";
+
+// ── deriveBgFromTheme ───────────────────────────────────────────────────────
+
+describe("deriveBgFromTheme", () => {
+	it("returns DEFAULT_DIFF_BG when theme is null", () => {
+		const result = deriveBgFromTheme(null);
+		expect(result).toEqual(DEFAULT_DIFF_BG);
+	});
+
+	it("returns DEFAULT_DIFF_BG when theme is undefined", () => {
+		const result = deriveBgFromTheme(undefined);
+		expect(result).toEqual(DEFAULT_DIFF_BG);
+	});
+
+	it("returns DEFAULT_DIFF_BG when theme lacks getFgAnsi", () => {
+		const result = deriveBgFromTheme({});
+		expect(result).toEqual(DEFAULT_DIFF_BG);
+	});
+
+	it("returns DEFAULT_DIFF_BG when getFgAnsi returns non-parseable values", () => {
+		const theme = {
+			getFgAnsi: () => "not-an-ansi-code",
+		};
+		const result = deriveBgFromTheme(theme);
+		expect(result).toEqual(DEFAULT_DIFF_BG);
+	});
+
+	it("derives colors from theme with valid getFgAnsi", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;100;200;150m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;100;100m";
+				return "";
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		// bgAdd should be a mix of black (base) + green accent at 0.08 intensity
+		expect(result.bgAdd).toMatch(/\x1b\[48;2;\d+;\d+;\d+m/);
+		expect(result.bgDel).toMatch(/\x1b\[48;2;\d+;\d+;\d+m/);
+		// Should differ from defaults since we have a theme
+		expect(result.bgAdd).not.toBe(DEFAULT_DIFF_BG.bgAdd);
+	});
+
+	it("uses bgBase from theme when getBgAnsi is available", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;100;200;150m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;100;100m";
+				return "";
+			},
+			getBgAnsi: (token: string) => {
+				if (token === "toolSuccessBg") return "\x1b[48;2;20;40;30m";
+				if (token === "toolErrorBg") return "\x1b[48;2;40;20;20m";
+				return "";
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		// bgBase should come from the theme's success bg
+		expect(result.bgBase).toBe("\x1b[48;2;20;40;30m");
+		// bgEmpty should equal bgBase
+		expect(result.bgEmpty).toBe(result.bgBase);
+	});
+
+	it("returns DiffBg with all required fields", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;100;200;150m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;100;100m";
+				return "";
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		expect(typeof result.bgAdd).toBe("string");
+		expect(typeof result.bgDel).toBe("string");
+		expect(typeof result.bgAddW).toBe("string");
+		expect(typeof result.bgDelW).toBe("string");
+		expect(typeof result.bgGutterAdd).toBe("string");
+		expect(typeof result.bgGutterDel).toBe("string");
+		expect(typeof result.bgEmpty).toBe("string");
+		expect(typeof result.bgBase).toBe("string");
+		expect(typeof result.rst).toBe("string");
+		expect(typeof result.divider).toBe("string");
+	});
+
+	it("bg colors are ANSI truecolor escapes (48;2;r;g;b format)", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;100;200;150m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;100;100m";
+				return "";
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		const bgFields = [
+			result.bgAdd,
+			result.bgDel,
+			result.bgAddW,
+			result.bgDelW,
+			result.bgGutterAdd,
+			result.bgGutterDel,
+		];
+		for (const bg of bgFields) {
+			expect(bg).toMatch(/\x1b\[48;2;\d+;\d+;\d+m/);
+		}
+	});
+
+	it("divider contains FG_RULE character", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;100;200;150m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;100;100m";
+				return "";
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		expect(result.divider).toContain(FG_RULE);
+	});
+
+	it("rst is reset when no bgBase from theme", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;100;200;150m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;100;100m";
+				return "";
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		// Without getBgAnsi, bgBase is \x1b[49m, so rst is just \x1b[0m
+		expect(result.rst).toBe("\x1b[0m");
+	});
+
+	it("rst includes bgBase reset when theme provides getBgAnsi", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;100;200;150m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;100;100m";
+				return "";
+			},
+			getBgAnsi: (token: string) => {
+				if (token === "toolSuccessBg") return "\x1b[48;2;20;40;30m";
+				return "";
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		// With getBgAnsi, rst should be \x1b[0m + bgBase
+		expect(result.rst).toBe("\x1b[0m\x1b[48;2;20;40;30m");
+	});
+
+	it("handles getFgAnsi that throws gracefully", () => {
+		const theme = {
+			getFgAnsi: () => {
+				throw new Error("theme error");
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		expect(result).toEqual(DEFAULT_DIFF_BG);
+	});
+
+	it("handles getBgAnsi that throws gracefully", () => {
+		const theme = {
+			getFgAnsi: (token: string) => {
+				if (token === "toolDiffAdded") return "\x1b[38;2;100;200;150m";
+				if (token === "toolDiffRemoved") return "\x1b[38;2;200;100;100m";
+				return "";
+			},
+			getBgAnsi: () => {
+				throw new Error("bg error");
+			},
+		};
+		const result = deriveBgFromTheme(theme);
+		// Should still produce valid output, falling back to default bgBase
+		expect(result.bgBase).toBe("\x1b[49m");
+		expect(result.rst).toBe("\x1b[0m");
+	});
+
+	it("property: rst always contains reset escape", () => {
+		fc.assert(
+			fc.property(
+				fc.array(
+					fc.tuple(
+						fc.constant("toolDiffAdded"),
+						fc.string({ maxLength: 20 }),
+					),
+					{ minLength: 0, maxLength: 5 },
+				),
+				(pairs) => {
+					const map = new Map(pairs);
+					const theme = {
+						getFgAnsi: (token: any) => map.get(token) || "",
+					};
+					const result = deriveBgFromTheme(theme);
+					return result.rst.includes("\x1b[0m");
+				},
+			),
+		);
+	});
+
+	it("property: all bg fields are valid truecolor bg escapes or defaults", () => {
+		fc.assert(
+			fc.property(
+				fc.string({ maxLength: 50 }),
+				(addColor) => {
+					const theme = {
+						getFgAnsi: (token: string) => {
+							if (token === "toolDiffAdded") return addColor;
+							if (token === "toolDiffRemoved") return addColor;
+							return "";
+						},
+					};
+					const result = deriveBgFromTheme(theme);
+					// Either we get valid truecolor bg escapes, or we get defaults
+					const isTruecolorBg = (s: string) => /\x1b\[48;2;\d+;\d+;\d+m/.test(s);
+					const allValid = [
+						result.bgAdd,
+						result.bgDel,
+						result.bgAddW,
+						result.bgDelW,
+						result.bgGutterAdd,
+						result.bgGutterDel,
+					].every((bg) => isTruecolorBg(bg));
+					const isDefault = result === DEFAULT_DIFF_BG || result.bgAdd === DEFAULT_DIFF_BG.bgAdd;
+					return allValid || isDefault;
+				},
+			),
+		);
+	});
+
+	it("property: divider always contains the rule character", () => {
+		fc.assert(
+			fc.property(
+				fc.string({ maxLength: 100 }),
+				(rawColor) => {
+					const theme = {
+						getFgAnsi: () => rawColor,
+					};
+					const result = deriveBgFromTheme(theme);
+					return result.divider.includes(FG_RULE);
+				},
+			),
+		);
+	});
+});

package/src/core/diff.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { parseDiff } from "./diff.js";
+
+// ── Multiline string generator for property tests ────────────────────────────
+
+const lineArb = fc.string({ maxLength: 80 });
+const multilineArb = fc.array(lineArb, { maxLength: 20 }).map(lines => lines.join("\n"));
+
+// ── parseDiff ────────────────────────────────────────────────────────────────
+
+describe("parseDiff", () => {
+	it("identical content returns empty lines and zero counts", () => {
+		const content = "line1\nline2\nline3";
+		const result = parseDiff(content, content);
+		expect(result.lines).toEqual([]);
+		expect(result.added).toBe(0);
+		expect(result.removed).toBe(0);
+		expect(result.chars).toBe(0);
+	});
+
+	it("single line addition", () => {
+		const old = "line1\n";
+		const newContent = "line1\nline2\n";
+		const result = parseDiff(old, newContent);
+		expect(result.added).toBe(1);
+		expect(result.removed).toBe(0);
+		const addLine = result.lines.find(l => l.type === "add");
+		expect(addLine).not.toBeUndefined();
+		expect(addLine!.content).toBe("line2");
+	});
+
+	it("single line deletion", () => {
+		const old = "line1\nline2\n";
+		const newContent = "line1\n";
+		const result = parseDiff(old, newContent);
+		expect(result.added).toBe(0);
+		expect(result.removed).toBe(1);
+		const delLine = result.lines.find(l => l.type === "del");
+		expect(delLine).not.toBeUndefined();
+		expect(delLine!.content).toBe("line2");
+	});
+
+	it("mixed add/delete/context", () => {
+		const old = "line1\nline2\nline3";
+		const newContent = "line1\nmodified\nline3\nline4";
+		const result = parseDiff(old, newContent);
+		expect(result.added).toBeGreaterThan(0);
+		expect(result.removed).toBeGreaterThan(0);
+		expect(result.lines.some(l => l.type === "ctx")).toBe(true);
+		expect(result.lines.some(l => l.type === "add")).toBe(true);
+		expect(result.lines.some(l => l.type === "del")).toBe(true);
+	});
+
+	it("multiple hunks produce separator", () => {
+		// Create content with changes far apart to trigger multiple hunks
+		const old = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np";
+		const newContent = "A\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\nP";
+		const result = parseDiff(old, newContent);
+		// With context=3, changes at start and end should create 2 hunks with a separator
+		expect(result.lines.some(l => l.type === "sep")).toBe(true);
+	});
+
+	it("context lines have both oldNum and newNum", () => {
+		const old = "line1\nline2\nline3";
+		const newContent = "line1\nmodified\nline3";
+		const result = parseDiff(old, newContent);
+		const ctxLines = result.lines.filter(l => l.type === "ctx");
+		for (const line of ctxLines) {
+			expect(line.oldNum).not.toBeNull();
+			expect(line.newNum).not.toBeNull();
+		}
+	});
+
+	it("added lines have only newNum", () => {
+		const old = "line1";
+		const newContent = "line1\nadded";
+		const result = parseDiff(old, newContent);
+		const addLines = result.lines.filter(l => l.type === "add");
+		for (const line of addLines) {
+			expect(line.oldNum).toBeNull();
+			expect(line.newNum).not.toBeNull();
+		}
+	});
+
+	it("deleted lines have only oldNum", () => {
+		const old = "line1\ndeleted";
+		const newContent = "line1";
+		const result = parseDiff(old, newContent);
+		const delLines = result.lines.filter(l => l.type === "del");
+		for (const line of delLines) {
+			expect(line.oldNum).not.toBeNull();
+			expect(line.newNum).toBeNull();
+		}
+	});
+
+	it("separator lines have null oldNum", () => {
+		const old = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np";
+		const newContent = "A\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\nP";
+		const result = parseDiff(old, newContent);
+		const sepLines = result.lines.filter(l => l.type === "sep");
+		for (const line of sepLines) {
+			expect(line.oldNum).toBeNull();
+		}
+	});
+
+	it("chars equals oldContent.length + newContent.length", () => {
+		const old = "hello";
+		const newContent = "world!!";
+		const result = parseDiff(old, newContent);
+		expect(result.chars).toBe(old.length + newContent.length);
+	});
+
+	it("handles empty strings", () => {
+		const result = parseDiff("", "");
+		expect(result.lines).toEqual([]);
+		expect(result.added).toBe(0);
+		expect(result.removed).toBe(0);
+	});
+
+	it("handles adding to empty", () => {
+		const result = parseDiff("", "new line");
+		expect(result.added).toBe(1);
+		expect(result.removed).toBe(0);
+	});
+
+	it("handles removing everything", () => {
+		const result = parseDiff("old line", "");
+		expect(result.added).toBe(0);
+		expect(result.removed).toBe(1);
+	});
+
+	// ── Property tests ───────────────────────────────────────────────────
+
+	it("property: reflexive — parseDiff(x, x).lines.length === 0", () => {
+		fc.assert(
+			fc.property(multilineArb, x => {
+				const result = parseDiff(x, x);
+				return result.lines.length === 0;
+			}),
+		);
+	});
+
+	it("property: non-negative — added >= 0 && removed >= 0", () => {
+		fc.assert(
+			fc.property(multilineArb, multilineArb, (a, b) => {
+				const result = parseDiff(a, b);
+				return result.added >= 0 && result.removed >= 0;
+			}),
+		);
+	});
+
+	it("property: chars equals sum of input lengths", () => {
+		fc.assert(
+			fc.property(multilineArb, multilineArb, (a, b) => {
+				const result = parseDiff(a, b);
+				if (a === b) {
+					return result.chars === 0;
+				}
+				return result.chars === a.length + b.length;
+			}),
+		);
+	});
+});

package/src/shiki.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as fc from "fast-check";
+
+// ── Mocks ────────────────────────────────────────────────────────────────────
+
+// Mock @shikijs/cli to avoid actual Shiki initialization
+vi.mock("@shikijs/cli", () => ({
+	codeToANSI: vi.fn().mockResolvedValue("mocked"),
+}));
+
+// Mock the ANSI normalization
+vi.mock("./ansi/index.js", () => ({
+	normalizeShikiContrast: vi.fn((s: string[]) => s),
+}));
+
+// ── Imports ──────────────────────────────────────────────────────────────────
+
+import { lang, setConfigGetter } from "./shiki.js";
+
+// ── lang ─────────────────────────────────────────────────────────────────────
+
+describe("lang", () => {
+	it("resolves .ts to typescript", () => {
+		expect(lang("file.ts")).toBe("typescript");
+	});
+
+	it("resolves .tsx to tsx", () => {
+		expect(lang("file.tsx")).toBe("tsx");
+	});
+
+	it("resolves .js to javascript", () => {
+		expect(lang("file.js")).toBe("javascript");
+	});
+
+	it("resolves .jsx to jsx", () => {
+		expect(lang("file.jsx")).toBe("jsx");
+	});
+
+	it("resolves .mjs to javascript", () => {
+		expect(lang("file.mjs")).toBe("javascript");
+	});
+
+	it("resolves .cjs to javascript", () => {
+		expect(lang("file.cjs")).toBe("javascript");
+	});
+
+	it("resolves .py to python", () => {
+		expect(lang("script.py")).toBe("python");
+	});
+
+	it("resolves .rb to ruby", () => {
+		expect(lang("script.rb")).toBe("ruby");
+	});
+
+	it("resolves .rs to rust", () => {
+		expect(lang("lib.rs")).toBe("rust");
+	});
+
+	it("resolves .go to go", () => {
+		expect(lang("main.go")).toBe("go");
+	});
+
+	it("resolves .java to java", () => {
+		expect(lang("Main.java")).toBe("java");
+	});
+
+	it("resolves .c to c", () => {
+		expect(lang("main.c")).toBe("c");
+	});
+
+	it("resolves .cpp to cpp", () => {
+		expect(lang("main.cpp")).toBe("cpp");
+	});
+
+	it("resolves .h to c", () => {
+		expect(lang("header.h")).toBe("c");
+	});
+
+	it("resolves .hpp to cpp", () => {
+		expect(lang("header.hpp")).toBe("cpp");
+	});
+
+	it("resolves .cs to csharp", () => {
+		expect(lang("Program.cs")).toBe("csharp");
+	});
+
+	it("resolves .swift to swift", () => {
+		expect(lang("main.swift")).toBe("swift");
+	});
+
+	it("resolves .kt to kotlin", () => {
+		expect(lang("Main.kt")).toBe("kotlin");
+	});
+
+	it("resolves .html to html", () => {
+		expect(lang("index.html")).toBe("html");
+	});
+
+	it("resolves .css to css", () => {
+		expect(lang("styles.css")).toBe("css");
+	});
+
+	it("resolves .scss to scss", () => {
+		expect(lang("styles.scss")).toBe("scss");
+	});
+
+	it("resolves .json to json", () => {
+		expect(lang("package.json")).toBe("json");
+	});
+
+	it("resolves .yaml to yaml", () => {
+		expect(lang("config.yaml")).toBe("yaml");
+	});
+
+	it("resolves .yml to yaml", () => {
+		expect(lang("config.yml")).toBe("yaml");
+	});
+
+	it("resolves .toml to toml", () => {
+		expect(lang("Cargo.toml")).toBe("toml");
+	});
+
+	it("resolves .md to markdown", () => {
+		expect(lang("README.md")).toBe("markdown");
+	});
+
+	it("resolves .sql to sql", () => {
+		expect(lang("query.sql")).toBe("sql");
+	});
+
+	it("resolves .sh to bash", () => {
+		expect(lang("script.sh")).toBe("bash");
+	});
+
+	it("resolves .bash to bash", () => {
+		expect(lang("script.bash")).toBe("bash");
+	});
+
+	it("resolves .zsh to bash", () => {
+		expect(lang("script.zsh")).toBe("bash");
+	});
+
+	it("resolves .lua to lua", () => {
+		expect(lang("init.lua")).toBe("lua");
+	});
+
+	it("resolves .php to php", () => {
+		expect(lang("index.php")).toBe("php");
+	});
+
+	it("resolves .dart to dart", () => {
+		expect(lang("main.dart")).toBe("dart");
+	});
+
+	it("resolves .xml to xml", () => {
+		expect(lang("config.xml")).toBe("xml");
+	});
+
+	it("resolves .graphql to graphql", () => {
+		expect(lang("schema.graphql")).toBe("graphql");
+	});
+
+	it("resolves .svelte to svelte", () => {
+		expect(lang("App.svelte")).toBe("svelte");
+	});
+
+	it("resolves .vue to vue", () => {
+		expect(lang("App.vue")).toBe("vue");
+	});
+
+	it("returns undefined for unknown extensions", () => {
+		expect(lang("file.unknown")).toBeUndefined();
+	});
+
+	it("returns undefined for no extension", () => {
+		expect(lang("Makefile")).toBeUndefined();
+	});
+
+	it("returns undefined for empty string", () => {
+		expect(lang("")).toBeUndefined();
+	});
+
+	it("is case-insensitive for extensions", () => {
+		expect(lang("file.TS")).toBe("typescript");
+		expect(lang("file.Ts")).toBe("typescript");
+		expect(lang("file.PY")).toBe("python");
+		expect(lang("file.JS")).toBe("javascript");
+	});
+
+	it("handles deep paths", () => {
+		expect(lang("/some/deep/path/to/file.ts")).toBe("typescript");
+	});
+
+	it("handles paths with dots in filename", () => {
+		expect(lang("my.file.name.ts")).toBe("typescript");
+	});
+
+	// ── Property tests ───────────────────────────────────────────────────
+
+	it("property: lang(x) returns consistent result for same extension", () => {
+		fc.assert(
+			fc.property(
+				fc.string({ minLength: 1, maxLength: 100 }),
+				filename => {
+					const result1 = lang(filename);
+					const result2 = lang(filename);
+					return result1 === result2;
+				},
+			),
+		);
+	});
+
+	it("property: lang only returns known languages or undefined", () => {
+		const knownLanguages = new Set([
+			"typescript", "tsx", "javascript", "jsx", "python", "ruby",
+			"rust", "go", "java", "c", "cpp", "csharp", "swift", "kotlin",
+			"html", "css", "scss", "json", "yaml", "toml", "markdown",
+			"sql", "bash", "lua", "php", "dart", "xml", "graphql",
+			"svelte", "vue",
+		]);
+
+		fc.assert(
+			fc.property(
+				fc.string({ minLength: 1, maxLength: 100 }),
+				filename => {
+					const result = lang(filename);
+					return result === undefined || knownLanguages.has(result);
+				},
+			),
+		);
+	});
+});
+
+// ── setConfigGetter ──────────────────────────────────────────────────────────
+
+describe("setConfigGetter", () => {
+	it("changes the config getter", async () => {
+		// Import hlBlock to test config getter effect
+		const { hlBlock } = await import("./shiki.js");
+
+		setConfigGetter(() => ({ diffTheme: "github-light" }));
+
+		// The config getter should now return the new theme
+		// We can't directly inspect _getConfig, but we can verify hlBlock
+		// doesn't throw and uses the new config
+		const result = await hlBlock("const x = 1;", "javascript");
+		expect(Array.isArray(result)).toBe(true);
+	});
+
+	it("accepts custom theme", async () => {
+		setConfigGetter(() => ({ diffTheme: "nord" }));
+
+		const { hlBlock } = await import("./shiki.js");
+		const result = await hlBlock("print('hello')", "python");
+		expect(Array.isArray(result)).toBe(true);
+	});
+
+	it("restores default behavior after setting", () => {
+		setConfigGetter(() => ({ diffTheme: "github-dark" }));
+		// Should not throw
+		expect(() => setConfigGetter(() => ({ diffTheme: "one-dark" }))).not.toThrow();
+	});
+});