@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/test/minimalist-templates.test.ts

@@ -0,0 +1,489 @@
+import { stripVTControlCharacters as plain } from "node:util";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it } from "vitest";
+import { codexQuotaText } from "../extensions/zentui/codex-quota-display";
+import { type MinimalistEditorStyleConfig, mergeConfig } from "../extensions/zentui/config";
+import {
+	type MinimalistEditorMetadata,
+	renderMinimalistFrame,
+} from "../extensions/zentui/minimalist-editor";
+import {
+	effectiveMinimalistFormats,
+	MINIMALIST_FORMAT_SLOTS,
+	type MinimalistFormats,
+	minimalistDemandsCustomVariable,
+	minimalistTemplateReferences,
+} from "../extensions/zentui/minimalist-template";
+
+const theme = { fg: (_color: string, text: string) => text, bold: (text: string) => text } as Theme;
+const emptySlots = Object.fromEntries(
+	MINIMALIST_FORMAT_SLOTS.map((slot) => [slot, ""]),
+) as MinimalistFormats;
+function config(
+	style: Partial<MinimalistEditorStyleConfig> = {},
+	colorSource = "theme",
+	quota = false,
+) {
+	return mergeConfig({
+		components: {
+			editor: {
+				style: "minimalist",
+				colorSource,
+				codexQuota: quota,
+				styles: { minimalist: { showCost: true, showTimer: true, ...style } },
+			},
+		},
+	});
+}
+function render(
+	style: Partial<MinimalistEditorStyleConfig> = {},
+	metadata: Partial<MinimalistEditorMetadata> = {},
+	width = 100,
+	colorSource = "theme",
+	extra = {},
+) {
+	return renderMinimalistFrame({
+		width,
+		editorLines: ["draft"],
+		inputText: "draft",
+		metadata: { cwd: "/repo", ...metadata },
+		uiTheme: theme,
+		config: config(style, colorSource),
+		...extra,
+	});
+}
+
+describe("Minimalist six-slot templates", () => {
+	it.each(MINIMALIST_FORMAT_SLOTS)("positions named values in %s", (slot) => {
+		const rows = render(
+			{ formats: { ...emptySlots, [slot]: "<$build>" }, variables: { build: "pkg.build" } },
+			{ customVariables: new Map([["pkg.build", "READY"]]) },
+		);
+		expect(rows).toHaveLength(3);
+		const border = slot.startsWith("top") ? rows[0] : rows[2];
+		expect(border).toContain("<READY>");
+		expect(rows[1]).toMatch(/^│ draft\s+│$/);
+		if (slot.endsWith("Left")) expect(border).toMatch(/^[╭╰]─ <READY>/);
+		if (slot.endsWith("Right")) expect(border).toMatch(/<READY> ─[╮╯]$/);
+		if (slot.endsWith("Middle")) expect(border.indexOf("<READY>")).toBe(Math.floor((100 - 7) / 2));
+	});
+
+	it("centers independently of side lengths, clamps safely, and omits an oversized center", () => {
+		const center = {
+			formats: { ...emptySlots, topLeft: "LEFT", topMiddle: "CENTER", topRight: "R" },
+		};
+		expect(render(center)[0].indexOf("CENTER")).toBe(47);
+		const clamped = render(
+			{ formats: { ...emptySlots, topLeft: "L".repeat(28), topMiddle: "CENTER", topRight: "R" } },
+			{},
+			45,
+		)[0];
+		expect(clamped).toContain("CENTER");
+		expect(clamped.indexOf("CENTER")).toBeGreaterThan(28);
+		const narrow = render(center, {}, 20)[0];
+		expect(narrow).not.toContain("CENTER");
+		expect(narrow).toContain("LEFT");
+		expect(narrow).toContain(" R ");
+	});
+
+	it("uses missing slots as defaults, and empty slots hide only configurable metadata", () => {
+		const metadata = {
+			costLabel: "$1",
+			modelLabel: "model",
+			branch: "main",
+			sessionName: "session",
+			agentDurationMs: 5000,
+			workingLineFrame: "Working",
+		};
+		const rows = render(
+			{ formats: { topLeft: "", topRight: "", bottomLeft: "" } },
+			metadata,
+			100,
+			"theme",
+			{ inputText: "!pwd", viewport: { above: "7", below: "8" } },
+		);
+		expect(rows[0]).toContain("↑ 7 more · $ · Working");
+		expect(rows[2]).toContain("↓ 8 more");
+		expect(rows[2]).toContain("repo");
+		expect(rows.join("\n")).not.toMatch(/session|5s|model|main|\$1/);
+	});
+
+	it("keeps operational viewport counts atomic and preserves Bash/Working content with empty custom formats", () => {
+		for (const width of [18, 24, 40, 80]) {
+			const rows = render(
+				{ formats: { ...emptySlots } },
+				{ workingLineFrame: "Working" },
+				width,
+				"theme",
+				{ inputText: "!pwd", viewport: { above: "123456789", below: "987654321" } },
+			);
+			expect(rows.every((row) => visibleWidth(row) <= width)).toBe(true);
+			expect(rows[0]).toContain("$ · Working");
+			if (rows[0].includes("more")) expect(rows[0]).toContain("↑ 123456789 more");
+			if (rows[2].includes("more")) expect(rows[2]).toContain("↓ 987654321 more");
+		}
+	});
+
+	it("respects nested conditional grammar and strips terminal controls from literal formats", () => {
+		const style = {
+			formats: { ...emptySlots, topLeft: "\x1b[31mSAFE\x1b[2J\n($build( / $missing))" },
+			variables: { build: "pkg.build" },
+		};
+		expect(render(style)[0]).toContain("SAFE");
+		expect(render(style)[0]).not.toContain("/");
+		const row = render(style, { customVariables: new Map([["pkg.build", "OK"]]) })[0];
+		expect(row).toContain("SAFE OK");
+		expect(row).not.toContain("\x1b[2J");
+		expect(row).not.toContain("/");
+	});
+
+	it("explicit builtin references override visibility toggles and preserve local formats", () => {
+		const rows = render(
+			{
+				showTimer: false,
+				showSessionName: false,
+				showCost: false,
+				showGit: false,
+				showCacheHit: false,
+				contextFormat: "percent-total",
+				pathDisplay: "full",
+				formats: {
+					...emptySlots,
+					topLeft: "$turn_duration · $session_name",
+					topRight: "$cost / $cache_hit / $context",
+					bottomLeft: "$git_branch $git_status",
+					bottomRight: "$cwd",
+				},
+			},
+			{
+				agentDurationMs: 5000,
+				sessionName: "session",
+				costLabel: "$1",
+				cacheHitRate: 75,
+				contextPercent: 42,
+				contextWindow: 100000,
+				branch: "main",
+				dirty: true,
+				cwd: "/repo/src",
+			},
+			140,
+		);
+		expect(rows[0]).toContain("5s · session");
+		expect(rows[0]).toContain("$1 / Cache 75.0% / 42%/100k");
+		expect(rows[2]).toContain("main *");
+		expect(rows[2]).toContain("/repo/src");
+	});
+
+	it("exposes model variants, provider, thinking, and supplied token counts", () => {
+		const rows = render(
+			{
+				formats: {
+					...emptySlots,
+					topLeft: "$model $model_id $model_name $provider $thinking",
+					topRight: "$tokens $input_tokens $output_tokens",
+				},
+			},
+			{
+				modelLabel: "chosen",
+				modelId: "id",
+				modelName: "name",
+				provider: "provider",
+				thinkingLevel: "high",
+				inputTokens: 1200,
+				outputTokens: 300,
+			},
+			140,
+		);
+		expect(rows[0]).toContain("chosen id name provider high");
+		expect(rows[0]).toContain("1.2k");
+		expect(rows[0]).toContain("300");
+		expect(
+			render({ formats: { ...emptySlots, topRight: "($thinking)" } }, { thinkingLevel: "off" })[0],
+		).not.toContain("off");
+	});
+});
+
+describe("Minimalist custom values and width safety", () => {
+	it("inserts the default aggregate after cost in deterministic key order", () => {
+		const row = render(
+			{},
+			{
+				costLabel: "$1",
+				modelLabel: "model",
+				thinkingLevel: "high",
+				contextPercent: 42,
+				customVariables: new Map([
+					["z.value", "Z"],
+					["a.value", "A"],
+				]),
+			},
+		)[0];
+		expect(row).toContain("$1 – A – Z – model – high – 42%");
+	});
+
+	it("skips explicitly referenced keys from the aggregate across all six effective slots", () => {
+		const rows = render(
+			{ formats: { bottomMiddle: "$build" }, variables: { build: "pkg.build", same: "pkg.build" } },
+			{
+				costLabel: "$1",
+				modelLabel: "model",
+				customVariables: new Map([
+					["pkg.build", "READY"],
+					["pkg.other", "OTHER"],
+				]),
+			},
+		);
+		expect(rows[0]).toContain("$1 – OTHER – model");
+		expect(rows.join("\n").match(/READY/g)).toHaveLength(1);
+	});
+
+	it("never appends values to explicit templates", () => {
+		const rows = render(
+			{ formats: { topRight: "$model" } },
+			{ modelLabel: "model", customVariables: new Map([["pkg.value", "VALUE"]]) },
+		);
+		expect(rows[0]).toContain("model");
+		expect(rows.join("\n")).not.toContain("VALUE");
+	});
+
+	it.each(["theme", "terminal"])(
+		"preserves Original SGR/link closures and applies Zentui color mode with %s colors",
+		(source) => {
+			const value = "\x1b[31mRED\x1b]8;;https://example.com\x1b\\LINK\x1b[2J\n界 e\u0301 👩‍💻";
+			const metadata = { customVariables: new Map([["pkg.value", value]]) };
+			const original = render(
+				{ formats: { ...emptySlots, topRight: "$value" }, variables: { value: "pkg.value" } },
+				metadata,
+				100,
+				source,
+			)[0];
+			expect(original).toContain("\x1b[31m");
+			expect(original).toMatch(/\x1b\]8;;(?:\x07|\x1b\\)/);
+			expect(original).not.toContain("\x1b[2J");
+			expect(original).toContain("\x1b[0m");
+			const zentui = render(
+				{
+					extensionColorMode: "zentui",
+					formats: { ...emptySlots, topRight: "$value" },
+					variables: { value: "pkg.value" },
+				},
+				metadata,
+				100,
+				source,
+			)[0];
+			expect(zentui).not.toContain("\x1b[31m");
+			expect(zentui).not.toContain("\x1b]8;");
+			expect(plain(zentui)).toContain("REDLINK 界 e\u0301 👩‍💻");
+		},
+	);
+
+	it("drops custom values whole before builtin sides and never clips Unicode values", () => {
+		const value = "界👩‍💻e\u0301-BUILD-READY";
+		for (let width = 5; width <= 100; width++) {
+			const rows = render(
+				{
+					formats: {
+						...emptySlots,
+						topLeft: "($value)",
+						topRight: "$model",
+						bottomRight: "($value)",
+					},
+					variables: { value: "pkg.value" },
+				},
+				{ modelLabel: "MODEL", customVariables: new Map([["pkg.value", `\x1b[31m${value}`]]) },
+				width,
+			);
+			for (const row of rows) {
+				expect(visibleWidth(row)).toBeLessThanOrEqual(width);
+				if (plain(row).includes("BUILD") || plain(row).includes("界"))
+					expect(plain(row)).toContain(value);
+			}
+			if (width >= 12) expect(rows[0]).toContain("MODEL");
+		}
+	});
+
+	it("keeps default builtin narrow fallbacks/gauges identical with oversized extensions", () => {
+		const metadata = {
+			costLabel: "$1",
+			modelLabel: "model".repeat(20),
+			thinkingLevel: "high",
+			contextPercent: 99,
+			contextWindow: 200000,
+			sessionName: "long session ".repeat(10),
+			agentDurationMs: 12000,
+		};
+		for (const width of [16, 20, 30, 40, 60]) {
+			const style = { contextGauge: true, contextFormat: "percent-total" as const };
+			expect(
+				render(
+					style,
+					{ ...metadata, customVariables: new Map([["pkg.value", "VALUE".repeat(40)]]) },
+					width,
+				),
+			).toEqual(render(style, metadata, width));
+		}
+	});
+
+	it("retains exact default output with no values or overrides", () => {
+		const metadata = {
+			costLabel: "$1",
+			modelLabel: "model",
+			thinkingLevel: "high",
+			contextPercent: 42,
+			sessionName: "session",
+			agentDurationMs: 5000,
+			branch: "main",
+		};
+		for (const source of ["theme", "terminal"])
+			for (const width of [1, 4, 5, 12, 20, 40, 80, 140]) {
+				expect(
+					render(
+						{ formats: {}, variables: {}, extensionColorMode: "original" },
+						{ ...metadata, customVariables: new Map() },
+						width,
+						source,
+					),
+				).toEqual(render({}, metadata, width, source));
+			}
+	});
+
+	it("retains default top-row narrow fallbacks when only an empty center slot is overridden", () => {
+		const metadata = {
+			costLabel: "$1",
+			modelLabel: "model".repeat(20),
+			thinkingLevel: "high",
+			contextPercent: 99,
+			contextWindow: 200000,
+			sessionName: "long session ".repeat(10),
+			agentDurationMs: 12000,
+		};
+		for (const width of [16, 20, 30, 40, 60, 100]) {
+			const style = { contextGauge: true, contextFormat: "percent-total" as const };
+			expect(render({ ...style, formats: { topMiddle: "" } }, metadata, width)[0]).toEqual(
+				render(style, metadata, width)[0],
+			);
+		}
+	});
+
+	it("requires quota consent even when referenced and keeps the entire quota atomic", () => {
+		const quota = { fiveHour: 80, week: 60 };
+		const style = {
+			formats: { ...emptySlots, topRight: "($codex_quota)($value)" },
+			variables: { value: "pkg.value" },
+		};
+		expect(render(style, { codexQuota: quota })[0]).not.toContain("5h");
+		for (let width = 5; width <= 100; width++) {
+			const rows = renderMinimalistFrame({
+				width,
+				editorLines: ["draft"],
+				inputText: "draft",
+				metadata: {
+					cwd: "",
+					codexQuota: quota,
+					customVariables: new Map([["pkg.value", "CUSTOM"]]),
+				},
+				uiTheme: theme,
+				config: config(style, "terminal", true),
+			});
+			for (const row of rows) {
+				expect(visibleWidth(row)).toBeLessThanOrEqual(width);
+				if (plain(row).includes("5h")) expect(plain(row)).toContain(codexQuotaText(quota));
+			}
+		}
+	});
+});
+
+describe("Minimalist effective template demand", () => {
+	it("reports generated defaults and honours explicit empty slots", () => {
+		const style = config().components.editor.styles.minimalist;
+		expect(effectiveMinimalistFormats(style).topRight).toContain("$cost$sep$extensions$sep$model");
+		expect(minimalistDemandsCustomVariable(style, "any.key")).toBe(true);
+		const noDemand = { ...style, formats: { ...emptySlots } };
+		expect(minimalistTemplateReferences(noDemand).size).toBe(0);
+		expect(minimalistDemandsCustomVariable(noDemand)).toBe(false);
+	});
+	it("reports nested aliases without executing publishers or conflating dormant config with ownership", () => {
+		const style = config({
+			showGit: false,
+			formats: { ...emptySlots, topLeft: "(($build))", bottomRight: "$cwd" },
+			variables: { build: "pkg.build", unused: "pkg.unused" },
+		}).components.editor.styles.minimalist;
+		expect([...minimalistTemplateReferences(style)]).toEqual(["build", "cwd"]);
+		expect(minimalistDemandsCustomVariable(style)).toBe(true);
+		expect(minimalistDemandsCustomVariable(style, "pkg.build")).toBe(true);
+		expect(minimalistDemandsCustomVariable(style, "pkg.unused")).toBe(false);
+	});
+});
+
+describe("Minimalist conditional joins", () => {
+	it.each(["dash", "dot"] as const)(
+		"joins actual bottomLeft fields with %s only when populated",
+		(separator) => {
+			const style = {
+				separator,
+				showSessionName: false,
+				showGit: false,
+				formats: { ...emptySlots, bottomLeft: "$session_name$join_sep($git_branch $git_status)" },
+			};
+			for (const [sessionName, branch, expected] of [
+				["Session", "", "Session"],
+				["", "branch", "branch"],
+				["Session", "branch", `Session ${separator === "dash" ? "–" : "·"} branch`],
+				["", "", ""],
+			]) {
+				const rows = render(style, { sessionName, branch });
+				if (expected) expect(plain(rows[2])).toMatch(new RegExp(`^╰─ ${expected} ─+╯$`));
+				else expect(rows).toEqual(render({ ...style, formats: { ...emptySlots } }));
+			}
+			expect(render(style, { sessionName: "Session", branch: "branch", dirty: true })[2]).toContain(
+				`Session ${separator === "dash" ? "–" : "·"} branch *`,
+			);
+			expect(render(style, { sessionName: "Session", dirty: true })[2]).toContain(
+				`Session ${separator === "dash" ? "–" : "·"}  *`,
+			);
+		},
+	);
+
+	it("preserves colored values and regenerates joins when custom values or quota yield", () => {
+		const style = {
+			formats: { ...emptySlots, bottomLeft: "$session_name$join_sep$value$join_sep$git_branch" },
+			variables: { value: "pkg.value" },
+		};
+		const metadata = {
+			sessionName: "S",
+			branch: "B",
+			customVariables: new Map([["pkg.value", "\x1b[31mCUSTOM\x1b[0m"]]),
+		};
+		const wide = render(style, metadata, 100, "terminal")[2];
+		expect(wide).toContain("\x1b[31mCUSTOM\x1b[0m");
+		expect(plain(wide)).toContain("S – CUSTOM – B");
+		for (const width of [15, 18, 22]) {
+			const rows = render(
+				style,
+				{ ...metadata, customVariables: new Map([["pkg.value", "CUSTOM".repeat(30)]]) },
+				width,
+				"terminal",
+			);
+			expect(plain(rows[2])).toContain("S – B");
+			expect(plain(rows[2])).not.toContain("– –");
+			expect(rows.every((row) => visibleWidth(row) <= width)).toBe(true);
+		}
+		const quotaStyle = {
+			formats: {
+				...emptySlots,
+				bottomLeft: "$session_name$join_sep$codex_quota$join_sep$git_branch",
+			},
+		};
+		const rows = renderMinimalistFrame({
+			width: 18,
+			editorLines: ["draft"],
+			inputText: "draft",
+			metadata: { cwd: "", sessionName: "S", branch: "B", codexQuota: { fiveHour: 80, week: 60 } },
+			uiTheme: theme,
+			config: config(quotaStyle, "terminal", true),
+		});
+		expect(plain(rows[2])).toContain("S – B");
+		expect(plain(rows[2])).not.toContain("5h");
+	});
+});