@luan.sh/pi-libtui 0.3.8

package/test/theme-colors.test.ts

@@ -0,0 +1,175 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { rgb } from "../src/color/palette.ts";
+import { createTuiThemeVariation, parseBackgroundAnsi, tuiTheme, tuiThemeAppearance } from "../src/color/theme.ts";
+import { terminalColorsRegistry } from "../src/terminal-colors.ts";
+
+afterEach(() => terminalColorsRegistry().publish(undefined));
+
+describe("TUI theme colors", () => {
+	test("derives an adjacent TUI theme by shifting surfaces and accent", () => {
+		const theme = {
+			name: "parent",
+			getFgAnsi: (token: string) => (token === "mdHeading" ? "\x1b[38;2;220;120;40m" : "\x1b[38;2;120;160;220m"),
+			getBgAnsi: (token: string) => (token === "toolPendingBg" ? "\x1b[48;2;10;20;30m" : "\x1b[48;2;40;50;60m"),
+		} as never as Theme;
+		const variation = createTuiThemeVariation(theme, "side");
+
+		expect(variation.name).toBe("side");
+		expect(variation.colors.accent).toBe("#dc7828");
+		expect(variation.colors.borderAccent).toBe("#dc7828");
+		expect(variation.colors.userMessageBg).toBe("#0a141e");
+		expect(variation.colors.toolPendingBg).toBe("#28323c");
+		expect(variation.colors.syntaxString).toBe("#78a0dc");
+	});
+
+	test("derives adjacent application appearance from the active Pi surface", () => {
+		const themed = (background: string) =>
+			({
+				name: "surface",
+				getBgAnsi: () => background,
+			}) as never as Theme;
+
+		expect(tuiThemeAppearance(themed("\x1b[48;2;20;24;30m"))).toBe("dark");
+		expect(tuiThemeAppearance(themed("\x1b[48;2;238;240;245m"))).toBe("light");
+	});
+
+	test("exposes generated semantic roles and stable hue swatches", () => {
+		const theme = {
+			name: "tokyo-night",
+			getColorMode: () => "truecolor",
+			getFgAnsi: (token: string) =>
+				({
+					error: "\x1b[38;2;247;118;142m",
+					success: "\x1b[38;2;158;206;106m",
+					warning: "\x1b[38;2;224;175;104m",
+					accent: "\x1b[38;2;122;162;247m",
+					border: "\x1b[38;2;59;66;97m",
+					mdHeading: "\x1b[38;2;255;158;100m",
+					syntaxKeyword: "\x1b[38;2;187;154;247m",
+					mdLink: "\x1b[38;2;125;207;255m",
+					muted: "\x1b[38;2;86;95;137m",
+					dim: "\x1b[38;2;59;66;97m",
+					text: "\x1b[39m",
+				})[token] ?? "\x1b[39m",
+			getBgAnsi: (token: string) => (token === "selectedBg" ? "\x1b[48;2;41;46;66m" : "\x1b[48;2;26;27;38m"),
+		} as never as Theme;
+		const colors = tuiTheme(theme);
+		const green = colors.color({ hue: "green", shade: 5 });
+		expect(green).toBe(colors.color({ hue: "green", shade: 5 }));
+		expect(colors.bgAnsi(green)).toBe("\x1b[48;2;158;206;106m");
+		expect(colors.fgAnsi("border")).toBe("\x1b[38;2;59;66;97m");
+		expect(colors.fgAnsi("heading")).toBe("\x1b[38;2;255;158;100m");
+		expect(colors.fgAnsi("accent")).toBe("\x1b[38;2;122;162;247m");
+		expect(colors.fgAnsi(colors.mixForeground("text.muted", "accent", 0))).toBe(colors.fgAnsi("text.muted"));
+		expect(colors.fgAnsi(colors.mixForeground("text.muted", "accent", 1))).toBe(colors.fgAnsi("accent"));
+		expect(colors.fgAnsi(colors.adjustForegroundBrightness("accent", 0))).toBe(colors.fgAnsi("accent"));
+		const indexedColors = tuiTheme({ ...theme, getColorMode: () => "256color" } as Theme);
+		expect(indexedColors.bgAnsi("diff.hunkHover")).not.toBe(indexedColors.bgAnsi("diff.hunk"));
+		expect(indexedColors.bgAnsi("diff.hunkGutterHover")).not.toBe(indexedColors.bgAnsi("diff.hunkGutter"));
+		const bg = (token: Parameters<typeof colors.bgAnsi>[0]) => parseBackgroundAnsi(colors.bgAnsi(token))!;
+		const added = bg("diff.added");
+		const removed = bg("diff.removed");
+		const addedGutter = bg("diff.addedGutter");
+		const removedGutter = bg("diff.removedGutter");
+		expect(added.g).toBeGreaterThan(added.r);
+		expect(removed.r).toBeGreaterThan(removed.g);
+		expect(addedGutter).not.toEqual(added);
+		expect(removedGutter).not.toEqual(removed);
+		expect(colors.bgAnsi("badge.positive")).toMatch(/^\x1b\[48;2;/);
+		expect(colors.fg("positive", "done")).toEndWith("done\x1b[39m");
+		const logical = colors.color("accent");
+		expect(colors.fg(logical, "custom")).toBe(`${colors.fgAnsi("accent")}custom\x1b[39m`);
+		expect(colors.bg(logical, "custom")).toBe(`${colors.bgAnsi(logical)}custom\x1b[49m`);
+		expect(() => colors.bgAnsi({} as never)).toThrow("Color must come from a pi-libtui TuiTheme");
+	});
+
+	test("re-resolves semantic color handles in the consuming theme", () => {
+		const hostTheme = (accent: string): Theme =>
+			({
+				name: `host-${accent}`,
+				getColorMode: () => "truecolor",
+				getFgAnsi: (token: string) =>
+					token === "accent"
+						? accent
+						: token === "border" || token === "mdHeading"
+							? "\x1b[38;2;70;80;90m"
+							: "\x1b[39m",
+				getBgAnsi: () => "\x1b[49m",
+			}) as never as Theme;
+		const first = tuiTheme(hostTheme("\x1b[38;2;10;20;30m"));
+		const accent = first.color("accent");
+		expect(first.color("border")).not.toBe(first.color("heading"));
+		const second = tuiTheme(hostTheme("\x1b[38;2;40;50;60m"));
+		expect(second.fg(accent, "accent")).toBe("\x1b[38;2;40;50;60maccent\x1b[39m");
+	});
+
+	test("reinterprets indexed opaque colors through the current terminal palette", () => {
+		const firstPalette = Array.from({ length: 16 }, (_, index) => rgb(index * 12, index * 6, index * 3));
+		const secondPalette = Array.from({ length: 16 }, (_, index) =>
+			rgb(255 - index * 12, 255 - index * 6, 255 - index * 3),
+		);
+		const theme = { name: "harmonious", getColorMode: () => "truecolor" } as Theme;
+		terminalColorsRegistry().publish({
+			scheme: "dark",
+			indexedPalette: "custom",
+			defaultBackground: firstPalette[0],
+			defaultForeground: firstPalette[15],
+			ansiBase16: firstPalette,
+		});
+		const first = tuiTheme(theme);
+		const accent = first.color("accent");
+		const firstAnsi = first.fgAnsi("accent");
+
+		terminalColorsRegistry().publish({
+			scheme: "light",
+			indexedPalette: "custom",
+			defaultBackground: secondPalette[0],
+			defaultForeground: secondPalette[15],
+			ansiBase16: secondPalette,
+		});
+		const second = tuiTheme(theme);
+		expect(second.fgAnsi("accent")).not.toBe(firstAnsi);
+		expect(second.fg(accent, "accent")).toBe(`${second.fgAnsi("accent")}accent\x1b[39m`);
+	});
+
+	test("derives cursor surfaces away from both dark and light backgrounds", () => {
+		const darkTheme = {
+			name: "dark-test",
+			getColorMode: () => "truecolor",
+			getFgAnsi: (token: string) => (token === "text" ? "\x1b[38;2;240;240;240m" : "\x1b[38;2;100;120;140m"),
+			getBgAnsi: () => "\x1b[48;2;24;28;36m",
+		} as never as Theme;
+		const lightTheme = {
+			name: "light-test",
+			getColorMode: () => "truecolor",
+			getFgAnsi: (token: string) => (token === "text" ? "\x1b[38;2;25;25;25m" : "\x1b[38;2;100;120;140m"),
+			getBgAnsi: (token: string) => (token === "selectedBg" ? "\x1b[48;2;210;215;225m" : "\x1b[48;2;235;238;242m"),
+		} as never as Theme;
+		const darkBase = parseBackgroundAnsi(tuiTheme(darkTheme).bgAnsi("surface.base"))!;
+		const darkCursor = parseBackgroundAnsi(tuiTheme(darkTheme).bgAnsi("surface.cursor"))!;
+		const lightBase = parseBackgroundAnsi(tuiTheme(lightTheme).bgAnsi("surface.base"))!;
+		const lightCursor = parseBackgroundAnsi(tuiTheme(lightTheme).bgAnsi("surface.cursor"))!;
+		const lightAdded = parseBackgroundAnsi(tuiTheme(lightTheme).bgAnsi("diff.added"))!;
+		const lightAddedGutter = parseBackgroundAnsi(tuiTheme(lightTheme).bgAnsi("diff.addedGutter"))!;
+		const lightRemoved = parseBackgroundAnsi(tuiTheme(lightTheme).bgAnsi("diff.removed"))!;
+		const lightRemovedGutter = parseBackgroundAnsi(tuiTheme(lightTheme).bgAnsi("diff.removedGutter"))!;
+		const lightHunk = parseBackgroundAnsi(tuiTheme(lightTheme).bgAnsi("diff.hunk"))!;
+		const lightHunkGutter = parseBackgroundAnsi(tuiTheme(lightTheme).bgAnsi("diff.hunkGutter"))!;
+		expect(darkCursor.r + darkCursor.g + darkCursor.b).toBeGreaterThan(darkBase.r + darkBase.g + darkBase.b);
+		expect(lightCursor.r + lightCursor.g + lightCursor.b).toBeLessThan(lightBase.r + lightBase.g + lightBase.b);
+		expect(lightAddedGutter).not.toEqual(lightAdded);
+		expect(lightRemovedGutter).not.toEqual(lightRemoved);
+		expect(lightHunk.b - Math.max(lightHunk.r, lightHunk.g)).toBeGreaterThan(0);
+		expect(lightHunkGutter.b - Math.max(lightHunkGutter.r, lightHunkGutter.g)).toBeGreaterThan(0);
+		expect(tuiTheme(lightTheme).fgAnsi("border")).toBe("\x1b[38;2;100;120;140m");
+		expect(tuiTheme(darkTheme).bgAnsi("surface.editor")).toBe("\x1b[48;2;19;22;28m");
+		expect(tuiTheme(lightTheme).bgAnsi("surface.editor")).toBe("\x1b[48;2;235;238;242m");
+		expect(tuiTheme(lightTheme).bgAnsi("surface.raised")).toBe("\x1b[48;2;235;238;242m");
+		expect(tuiTheme(lightTheme).bgAnsi("surface.selected")).toBe("\x1b[48;2;210;215;225m");
+		expect(tuiTheme(lightTheme).bgAnsi("surface.inset")).toMatch(/^\x1b\[48;2;/);
+		expect(tuiTheme(lightTheme).bgAnsi("surface.inset")).not.toBe("\x1b[48;5;0m");
+		const semanticAccent = tuiTheme(darkTheme).color("accent");
+		expect(tuiTheme(lightTheme).fg(semanticAccent, "accent")).toBe("\x1b[38;2;100;120;140maccent\x1b[39m");
+	});
+});

package/test/tool-output.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, test } from "bun:test";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences, visibleWidth } from "@earendil-works/pi-tui";
+import { ToolOutput } from "../src/tool/output.ts";
+
+const theme = {
+	name: "output-test",
+	getColorMode: () => "truecolor",
+	getFgAnsi: () => "\x1b[38;2;180;180;180m",
+	getBgAnsi: () => "\x1b[48;2;20;20;20m",
+} as never as Theme;
+
+describe("ToolOutput", () => {
+	test("makes append and replace explicit while caching exact revisions", () => {
+		const output = new ToolOutput({ theme, initial: { text: "one", revision: 1 } });
+		const first = output.render(20);
+		expect(output.render(20)).toBe(first);
+		output.append(" two", 2);
+		expect(stripTerminalSequences(output.render(20).join("\n"))).toContain("one two");
+		output.replace({ text: "replacement", revision: 3 });
+		expect(stripTerminalSequences(output.render(20).join("\n"))).toBe("replacement");
+	});
+
+	test("applies caller-owned bounded viewports without breaking ANSI width", () => {
+		const text = Array.from({ length: 100 }, (_, index) => `\x1b[3${index % 8}mline-${index}-long\x1b[39m`).join("\n");
+		const output = new ToolOutput({
+			theme,
+			initial: { text, revision: 1 },
+			viewport: { maxRows: 5 },
+		});
+		const collapsed = output.render(8);
+		expect(collapsed).toHaveLength(5);
+		expect(collapsed.every((line) => visibleWidth(line) <= 8)).toBe(true);
+		output.setViewport({ maxRows: 12, selection: "tail" });
+		expect(output.render(8)).toHaveLength(12);
+	});
+
+	test("keeps an exact head-tail omission row inside the bounded output", () => {
+		const output = new ToolOutput({
+			theme,
+			initial: { text: "line 0\nline 1\nline 2\nline 3\nline 4\nline 5", revision: 1 },
+			viewport: { maxRows: 4, selection: "head-tail" },
+		});
+
+		expect(stripTerminalSequences(output.render(20).join("\n"))).toBe("line 0\n… 3 rows omitted …\nline 4\nline 5");
+		expect(output.getOmissionRow()).toBe(1);
+	});
+
+	test("bounds retained append content under stress", () => {
+		const output = new ToolOutput({ theme, maxCharacters: 128, viewport: { maxRows: 20, selection: "tail" } });
+		for (let revision = 1; revision <= 10_000; revision++) output.append(`${revision},`, revision);
+		const rendered = stripTerminalSequences(output.render(80).join("\n"));
+		expect(rendered).toContain("earlier characters discarded");
+		expect(rendered.length).toBeLessThan(300);
+	});
+
+	test("keeps the retention marker inside a one-row viewport", () => {
+		const output = new ToolOutput({
+			theme,
+			initial: { text: "discard this and retain the tail", revision: 1 },
+			maxCharacters: 8,
+			viewport: { maxRows: 1 },
+		});
+
+		const rendered = output.render(80);
+		expect(rendered).toHaveLength(1);
+		expect(stripTerminalSequences(rendered[0]!)).toContain("earlier characters discarded");
+	});
+
+	test("never retains the tail half of an ANSI control sequence", () => {
+		const output = new ToolOutput({ theme, maxCharacters: 8, viewport: { maxRows: 20 } });
+		output.append(`before\x1b[38;2;100;120;140mcolored\x1b[39m`, 1);
+		const plain = stripTerminalSequences(output.render(80).join("\n"));
+		expect(plain).not.toMatch(/\[\d+(?:;\d+)*m/);
+	});
+
+	test("preserves SGR styling but removes terminal side-effect controls", () => {
+		const output = new ToolOutput({
+			theme,
+			initial: {
+				text: "\x1b[31mred\x1b[0m\x1b]52;c;Y2xpcGJvYXJk\x07\x1bPpayload\x1b\\safe",
+				revision: 1,
+			},
+		});
+		const rendered = output.render(80).join("\n");
+		expect(rendered).toContain("\x1b[31mred\x1b[0m");
+		expect(rendered).not.toContain("]52");
+		expect(rendered).not.toContain("payload");
+		expect(stripTerminalSequences(rendered)).toBe("redsafe");
+	});
+
+	test("removes eight-bit OSC and DCS controls with their payloads", () => {
+		const output = new ToolOutput({
+			theme,
+			initial: { text: "before\u009d52;c;secret\u0007middle\u0090device\u009cafter", revision: 1 },
+		});
+		expect(stripTerminalSequences(output.render(80).join("\n"))).toBe("beforemiddleafter");
+	});
+
+	test("carries split SGR sequences across cumulative snapshots", () => {
+		const output = new ToolOutput({ theme });
+		output.appendCumulative("\x1b[31", 1);
+		expect(output.render(80)).toEqual([]);
+		output.appendCumulative("\x1b[31mred", 2);
+		const rendered = output.render(80).join("\n");
+		expect(rendered).toContain("\x1b[31mred");
+		expect(stripTerminalSequences(rendered)).toBe("red");
+	});
+
+	test("bounds unterminated terminal controls without leaking their payload", () => {
+		const output = new ToolOutput({ theme, maxCharacters: 16 });
+		output.append(`\x1b]52;c;${"secret".repeat(20_000)}`, 1);
+		expect(output.render(80)).toEqual([]);
+		output.append("\x07safe", 2);
+		expect(stripTerminalSequences(output.render(80).join("\n"))).toBe("safe");
+	});
+
+	test("bounds unterminated CSI state even below its introducer width", () => {
+		const output = new ToolOutput({ theme, maxCharacters: 1 });
+		output.append(`\x1b[${"1".repeat(100_000)}`, 1);
+		expect(output.render(80)).toEqual([]);
+		output.append("msafe", 2);
+		const rendered = stripTerminalSequences(output.render(80).join("\n"));
+		expect(rendered).toEndWith("e");
+		expect(rendered).not.toContain("1111");
+	});
+
+	test("bounds sanitization work before retaining large resumed output", () => {
+		const source = "x".repeat(100_000);
+		const output = new ToolOutput({ theme, initial: { text: source, revision: 0 }, maxCharacters: 1_000 });
+		expect(stripTerminalSequences(output.render(80).join("\n"))).toContain("earlier characters discarded");
+	});
+
+	test("clips pathological single lines before wrapping", () => {
+		const output = new ToolOutput({
+			theme,
+			initial: { text: "x".repeat(1_000_000), revision: 1 },
+			maxCharacters: 1_000_000,
+			viewport: { maxRows: 20 },
+		});
+		const rendered = stripTerminalSequences(output.render(1).join("\n"));
+
+		expect(rendered).toContain("…");
+		expect(output.render(1)).toHaveLength(20);
+		expect(rendered.length).toBeLessThan(100);
+	});
+
+	test("normalizes non-finite retention limits and appends cumulative snapshots by delta", () => {
+		const output = new ToolOutput({
+			theme,
+			maxCharacters: Number.POSITIVE_INFINITY,
+			viewport: { maxRows: 4, selection: "tail" },
+		});
+		output.appendCumulative("one", 1);
+		output.appendCumulative("one\ntwo", 2);
+		expect(stripTerminalSequences(output.render(40).join("\n"))).toBe("one\ntwo");
+		output.append("x".repeat(1_000_001), 3);
+		expect(stripTerminalSequences(output.render(40)[0] ?? "")).toContain("earlier characters discarded");
+	});
+});