@selesai/code 0.13.16 → 0.13.18

package/dist/extensions/pi-zentui/test/extension-status.test.ts

@@ -48,6 +48,78 @@ describe("sanitizeExtensionStatusText", () => {
 });
 
 describe("sanitizeExtensionStatusOriginalText", () => {
+	it.each(["\x07", "\x1b\\"])(
+		"closes a surviving link when a title swallows its closer (%j)",
+		(end) => {
+			const open = "\x1b]8;;https://example.com/\x07";
+			expect(
+				sanitizeExtensionStatusOriginalText(`${open}A\x1b]0;title\x1b]8;;${end}${end} tail`),
+			).toBe(`${open}A tail\x1b]8;;\x07`);
+		},
+	);
+
+	it.each(["\x07", "\x1b\\"])("does not restore a link opener swallowed by a title (%j)", (end) => {
+		expect(
+			sanitizeExtensionStatusOriginalText(
+				`\x1b]0;title\x1b]8;;https://example.com/${end}${end}plain`,
+			),
+		).toBe("plain");
+	});
+
+	it.each(["javascript:alert(1)", "file:///tmp/report", "not-a-url"])(
+		"closes the surviving link before a later invalid target %j",
+		(url) => {
+			const open = "\x1b]8;;https://example.com/\x07";
+			expect(
+				sanitizeExtensionStatusOriginalText(
+					`${open}A\x1b]0;title\x1b]8;;\x07\x07\x1b]8;;${url}\x07plain`,
+				),
+			).toBe(`${open}A\x1b]8;;\x07plain`);
+		},
+	);
+	it.each(["\x07", "\x1b\\"])("preserves HTTP(S) OSC 8 links terminated by %j", (end) => {
+		const source = `\x1b]8;id=pr;https://example.com/pull/123${end}PR #123\x1b]8;;${end}`;
+		expect(sanitizeExtensionStatusOriginalText(source)).toBe(
+			"\x1b]8;;https://example.com/pull/123\x07PR #123\x1b]8;;\x07",
+		);
+		expect(sanitizeExtensionStatusText(source)).toBe("PR #123");
+	});
+
+	it("preserves styling inside links and keeps following text outside the link", () => {
+		expect(
+			sanitizeExtensionStatusOriginalText(
+				"\x1b]8;;http://example.com/pr/1\x07\x1b[31mPR #1\x1b[0m\x1b]8;;\x07 | failed",
+			),
+		).toBe("\x1b]8;;http://example.com/pr/1\x07\x1b[31mPR #1\x1b[0m\x1b]8;;\x07 | failed");
+	});
+
+	it.each([
+		"javascript:alert(1)",
+		"file:///tmp/report",
+		"not-a-url",
+		"https://example.com/\u0085x",
+	])("drops an unsafe OSC 8 target %j while retaining its label", (url) =>
+		expect(sanitizeExtensionStatusOriginalText(`\x1b]8;;${url}\x07PR #1\x1b]8;;\x07`)).toBe(
+			"PR #1",
+		),
+	);
+
+	it("closes an unterminated link and does not retain clipboard or cursor controls", () => {
+		expect(
+			sanitizeExtensionStatusOriginalText(
+				"\x1b]52;c;YQ==\x07\x1b[2J\x1b]8;;https://example.com/pr/1\x07PR #1",
+			),
+		).toBe("\x1b]8;;https://example.com/pr/1\x07PR #1\x1b]8;;\x07");
+		expect(
+			sanitizeExtensionStatusOriginalText("\x1b]8;;https://example.com/pr/1\x07\x1b]8;;\x07"),
+		).toBe("");
+	});
+
+	it("does not interpret visible placeholder-shaped text as control sequences", () => {
+		expect(sanitizeExtensionStatusOriginalText("__ZENTUI_SGR_0__ \x1b[31mred\x1b[0m")).toBe(
+			"__ZENTUI_SGR_0__ \x1b[31mred\x1b[0m",
+		);
+	});
 	it("preserves SGR color while stripping unsafe control sequences", () => {
 		expect(sanitizeExtensionStatusOriginalText("\x1b[31mred\x1b[0m\nnext\tline")).toBe(
 			"\x1b[31mred\x1b[0m next line",
@@ -66,6 +138,24 @@ describe("sanitizeExtensionStatusOriginalText", () => {
 });
 
 describe("collectExtensionStatusSegments", () => {
+	it("preserves links only for original-color statuses without changing their placement", () => {
+		const link = "\x1b]8;;https://example.com/pull/123\x07PR #123\x1b]8;;\x07";
+		const config = configWithExtensionStatuses({
+			placements: { pr: "right" },
+			colorModes: { pr: "original" },
+		});
+		const segments = collectExtensionStatusSegments(
+			new Map([
+				["pr", link],
+				["plain", link],
+			]),
+			config,
+		);
+		expect(segments.right).toEqual([
+			{ key: "plain", text: "PR #123", placement: "right", colorMode: "zentui" },
+			{ key: "pr", text: link, placement: "right", colorMode: "original" },
+		]);
+	});
 	it("routes active statuses by placement and defaults unsaved keys to right", () => {
 		const config = configWithExtensionStatuses({
 			placements: {

package/dist/extensions/pi-zentui/test/footer-hyperlink.test.ts

@@ -0,0 +1,243 @@
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { defaultConfig, type ZentuiConfig } from "../extensions/zentui/config";
+import { installFooter } from "../extensions/zentui/footer";
+import { packCompactChunks } from "../extensions/zentui/footer-layout";
+import { truncateFooterText } from "../extensions/zentui/footer-text";
+import { emptyGitStatus } from "../extensions/zentui/git";
+import { createInitialState } from "../extensions/zentui/state";
+
+vi.mock("@earendil-works/pi-tui", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@earendil-works/pi-tui")>();
+	return { ...actual, truncateToWidth: vi.fn(actual.truncateToWidth) };
+});
+
+const actualTui =
+	await vi.importActual<typeof import("@earendil-works/pi-tui")>("@earendil-works/pi-tui");
+const url = "https://example.com/pull/123";
+const longLabel = "abcdefghijklmnopqrstuvwxyz".repeat(4);
+const link = (label: string, end = "\x07") => `\x1b]8;;${url}${end}${label}\x1b]8;;${end}`;
+
+// Isolated old-host model: preserve complete ANSI controls in the retained prefix,
+// but append only an SGR reset on truncation, as Pi TUI 0.80.5 does. Never rely
+// on the installed (possibly link-safe) truncateToWidth implementation here.
+function legacyTruncate(text: string, width: number, ellipsis = "..."): string {
+	if (width <= 0) return "";
+	if (visibleWidth(text) <= width) return text;
+	if (visibleWidth(ellipsis) >= width) return ellipsis.slice(0, width);
+	let result = "";
+	let used = 0;
+	for (const token of text.match(/\x1b\[[0-9;:]*m|\x1b\]8;[^\x07\x1b]*(?:\x07|\x1b\\)|./gu) ?? []) {
+		const size = visibleWidth(token);
+		if (used + size > width - visibleWidth(ellipsis)) break;
+		result += token;
+		used += size;
+	}
+	return `${result}\x1b[0m${ellipsis}`;
+}
+
+function linkState(text: string) {
+	let active = false;
+	let linked = "";
+	let plain = "";
+	for (const token of text.match(/\x1b\[[0-9;:]*m|\x1b\]8;[^\x07\x1b]*(?:\x07|\x1b\\)|./gu) ?? []) {
+		if (token.startsWith("\x1b]8;")) active = !/^\x1b\]8;;(?:\x07|\x1b\\)$/.test(token);
+		else if (!token.startsWith("\x1b")) {
+			if (active) linked += token;
+			else plain += token;
+		}
+	}
+	return { active, linked, plain };
+}
+
+function renderFooter(
+	config: ZentuiConfig,
+	statuses: Map<string, string>,
+	width: number,
+): string[] {
+	let factory: Parameters<ExtensionContext["ui"]["setFooter"]>[0];
+	const ctx = {
+		cwd: "/repo",
+		getContextUsage: () => undefined,
+		sessionManager: { getSessionName: () => undefined },
+		ui: {
+			setFooter(value: typeof factory) {
+				factory = value;
+			},
+		},
+	} as unknown as ExtensionContext;
+	installFooter(ctx, createInitialState(emptyGitStatus()), () => config, {
+		setRequestRender() {},
+		scheduleProjectRefresh() {},
+	});
+	const footer = factory?.(
+		{ requestRender() {} } as never,
+		{ fg: (_color: string, text: string) => text } as Theme,
+		{ onBranchChange: () => () => {}, getExtensionStatuses: () => statuses } as never,
+	);
+	expect(footer).toBeDefined();
+	try {
+		return footer?.render(width) ?? [];
+	} finally {
+		footer?.dispose?.();
+	}
+}
+
+for (const host of ["installed", "legacy"] as const) {
+	describe(`footer status hyperlinks (${host} truncation)`, () => {
+		beforeEach(() => {
+			vi.mocked(truncateToWidth).mockImplementation(
+				host === "legacy" ? legacyTruncate : actualTui.truncateToWidth,
+			);
+		});
+
+		it("models the old host's missing OSC 8 close independently of installed Pi", () => {
+			const text = legacyTruncate(link(longLabel), 8, "…");
+			expect(text).toBe(`\x1b]8;;${url}\x07abcdefg\x1b[0m…`);
+			expect(linkState(text).active).toBe(true);
+		});
+
+		for (const responsive of [false, true]) {
+			for (const placement of ["left", "middle", "right"] as const) {
+				it.each(["\x07", "\x1b\\"])(
+					`truncates long ${placement} links safely (responsive=${responsive}, %j)`,
+					(end) => {
+						const config = structuredClone(defaultConfig);
+						const style = config.components.footer.styles.starship;
+						style.responsive = responsive;
+						style.format = "LEFT$fill RIGHT";
+						style.compactFormat = "$extensions $wrap_sep SUFFIX";
+						style.extensionStatuses.colorModes.pr = "original";
+						style.extensionStatuses.placements.pr = placement;
+						const lines = renderFooter(config, new Map([["pr", link(longLabel, end)]]), 20);
+						expect(lines.join("")).toContain("…");
+						expect(lines.join("")).not.toContain(longLabel);
+						expect(lines.join("")).toContain(`\x1b]8;;${url}\x07`);
+						for (const line of lines) {
+							expect(visibleWidth(line)).toBeLessThanOrEqual(20);
+							const state = linkState(`${line}NEIGHBOR`);
+							expect(state.active).toBe(false);
+							expect(state.linked).toMatch(/^[a-z…]*$/);
+							expect(state.plain).toContain("NEIGHBOR");
+						}
+					},
+				);
+
+				it(`isolates malformed ${placement} statuses from neighbors (responsive=${responsive})`, () => {
+					const config = structuredClone(defaultConfig);
+					const style = config.components.footer.styles.starship;
+					style.responsive = responsive;
+					style.format = "LEFT$fill RIGHT";
+					style.extensionStatuses.colorModes.pr = "original";
+					style.extensionStatuses.placements = { pr: placement, zz: placement };
+					const malformed = "\x1b]8;;https://example.com/\x07A\x1b]0;title\x1b]8;;\x07\x07 tail";
+					const lines = renderFooter(
+						config,
+						new Map([
+							["pr", malformed],
+							["zz", "PLAIN"],
+						]),
+						80,
+					);
+					const state = linkState(lines.join(""));
+					expect(state.active).toBe(false);
+					expect(state.linked).toBe("A tail");
+					expect(state.plain).toContain("PLAIN");
+					expect(state.plain).toContain("RIGHT");
+				});
+			}
+		}
+
+		it.each([20, 40, 80, 160])(
+			"preserves short links and plain suffixes at %i columns",
+			(width) => {
+				const config = structuredClone(defaultConfig);
+				const style = config.components.footer.styles.starship;
+				style.format = "demo$fill";
+				style.compactFormat = "$extensions";
+				style.extensionStatuses.colorModes.pr = "original";
+				const lines = renderFooter(
+					config,
+					new Map([["pr", `${link("PR #123")} | pending`]]),
+					width,
+				);
+				expect(lines.every((line) => visibleWidth(line) <= width)).toBe(true);
+				expect(lines.join("\n")).toContain(link("PR #123"));
+				expect(linkState(lines.join("")).linked).toBe("PR #123");
+				expect(linkState(lines.join("")).plain).toContain("pending");
+			},
+		);
+
+		it("closes links when compact omission truncates a previously joined row", () => {
+			const rows = packCompactChunks(
+				[
+					{ text: `PLAIN ${link("abcdefghijk")}`, boundary: "space" },
+					{ text: "OMITTED", boundary: "space" },
+				],
+				17,
+				1,
+				" | ",
+			);
+			expect(rows).toHaveLength(1);
+			expect(rows[0]).toContain("…");
+			expect(linkState(`${rows[0]}NEIGHBOR`).plain).toContain("NEIGHBOR");
+			expect(linkState(rows[0] ?? "").active).toBe(false);
+			expect(visibleWidth(rows[0] ?? "")).toBe(17);
+		});
+
+		it.each([0, 1, 2, 3, 8, 20, 160])(
+			"closes BEL/ST links at fragment boundaries of width %i",
+			(width) => {
+				for (const end of ["\x07", "\x1b\\"]) {
+					for (const ellipsis of ["", "…"]) {
+						const text = `PLAIN ${link("first", end)} | ${link(longLabel, end)} SUFFIX`;
+						const result = truncateFooterText(text, width, ellipsis);
+						expect(visibleWidth(result)).toBeLessThanOrEqual(width);
+						expect(linkState(`${result}NEIGHBOR`).plain).toContain("NEIGHBOR");
+						expect(linkState(result).linked).toMatch(/^[a-z…]*$/);
+					}
+				}
+			},
+		);
+
+		it.each([1, 2, 3, 4, 8])("bounds compact footer frames at %i columns", (width) => {
+			const config = structuredClone(defaultConfig);
+			const style = config.components.footer.styles.starship;
+			style.format = "LEFT$fill RIGHT";
+			style.compactFormat = "$extensions";
+			style.extensionStatuses.colorModes.pr = "original";
+			const lines = renderFooter(config, new Map([["pr", link(longLabel)]]), width);
+			for (const line of lines) {
+				expect(visibleWidth(line)).toBeLessThanOrEqual(width);
+				expect(linkState(`${line}NEIGHBOR`).plain).toContain("NEIGHBOR");
+			}
+		});
+
+		it("leaves plain and SGR-only truncation unchanged", () => {
+			for (const text of ["plain", "\x1b[31mred label\x1b[0m", "界 e\u0301 wide text"]) {
+				for (const width of [0, 1, 8, 80]) {
+					expect(truncateFooterText(text, width, "…")).toBe(truncateToWidth(text, width, "…"));
+				}
+			}
+		});
+
+		it("keeps adjacent plain and built-in chunks outside links", () => {
+			const rows = packCompactChunks(
+				[
+					{ text: link("label"), boundary: "space" },
+					{ text: "PLAIN", boundary: "space" },
+					{ text: "BUILTIN", boundary: "separator" },
+				],
+				40,
+				1,
+				" | ",
+			);
+			expect(linkState(rows[0] ?? "")).toEqual({
+				active: false,
+				linked: "label",
+				plain: " PLAIN | BUILTIN",
+			});
+		});
+	});
+}

package/dist/extensions/pi-zentui/test/package-contents.mjs

@@ -15,6 +15,7 @@ assert.equal(packages.length, 1, "npm pack must report exactly one package");
 const files = packages[0]?.files;
 assert.ok(Array.isArray(files), "npm pack must report its package file list");
 for (const required of [
+	"docs/configuration.md",
 	"extensions/zentui/thinking-steps.ts",
 	"extensions/zentui/thinking-experimental.ts",
 	"extensions/zentui/thinking-status.ts",

package/dist/extensions/pi-zentui/test/presets.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import { defaultConfig, mergeConfig } from "../extensions/zentui/config";
+import {
+	componentPresets,
+	getComponentPreset,
+	matchingComponentPreset,
+} from "../extensions/zentui/presets";
+
+describe("component presets", () => {
+	it("defines exactly the four selection-only maps", () => {
+		expect(componentPresets.map(({ id, components }) => ({ id, components }))).toEqual([
+			{
+				id: "opencode",
+				components: {
+					editor: { enabled: true, style: "opencode" },
+					footer: { style: "starship" },
+					userMessages: { enabled: true, style: "framed" },
+				},
+			},
+			{
+				id: "opencode-copy-friendly",
+				components: {
+					editor: { enabled: true, style: "opencode-copy-friendly" },
+					footer: { style: "starship" },
+					userMessages: { enabled: true, style: "framed-copy-friendly" },
+				},
+			},
+			{
+				id: "rail",
+				components: {
+					editor: { enabled: true, style: "accent-rail" },
+					footer: { style: "starship" },
+					userMessages: { enabled: true, style: "compact" },
+				},
+			},
+			{
+				id: "minimalist",
+				components: {
+					editor: { enabled: true, style: "minimalist" },
+					footer: { style: "hidden" },
+					userMessages: { enabled: false },
+				},
+			},
+		]);
+	});
+
+	it("leaves the Selesai defaults unchanged and classified as custom", () => {
+		expect(matchingComponentPreset(defaultConfig)).toBeUndefined();
+		expect(matchingComponentPreset(mergeConfig({}))).toBeUndefined();
+	});
+
+	it.each(["", "custom", "default", "Opencode", "opencode_copy_friendly", "constructor"])(
+		"rejects unknown ID %s",
+		(id) => {
+			expect(getComponentPreset(id)).toBeUndefined();
+		},
+	);
+
+	for (const preset of componentPresets) {
+		it(`matches ${preset.id} independent of colors, options, and unrelated components`, () => {
+			const config = mergeConfig({ components: preset.components });
+			config.colors.cwd = "red";
+			config.icons.mode = "ascii";
+			config.components.editor.colorSource = "terminal";
+			config.components.editor.styles.minimalist.showGit = false;
+			config.components.userMessages.colorSource = "terminal";
+			config.components.footer.colorSource = "terminal";
+			config.components.footer.styles.starship.format = "$cwd";
+			config.components.footer.styles.starship.segments.context = false;
+			config.components.workingLine.enabled = true;
+			config.components.thinkingSteps.enabled = true;
+			config.components.selectorBorders.enabled = false;
+			expect(matchingComponentPreset(config)?.id).toBe(preset.id);
+		});
+
+		for (const owner of ["editor", "footer", "userMessages"] as const) {
+			for (const [key, value] of Object.entries(preset.components[owner])) {
+				it(`detects ${preset.id} drift in ${owner}.${key} and restores matching after manual repair`, () => {
+					const components = structuredClone(preset.components);
+					Object.assign(components[owner], {
+						[key]:
+							typeof value === "boolean"
+								? !value
+								: owner === "footer"
+									? "native"
+									: owner === "editor"
+										? "minimalist"
+										: "labeled",
+					});
+					if (preset.id === "minimalist" && owner === "editor" && key === "style")
+						Object.assign(components.editor, { style: "opencode" });
+					expect(matchingComponentPreset(mergeConfig({ components }))).toBeUndefined();
+					Object.assign(components[owner], { [key]: value });
+					expect(matchingComponentPreset(mergeConfig({ components }))?.id).toBe(preset.id);
+				});
+			}
+		}
+	}
+
+	it.each(["editor", "footer", "userMessages"] as const)(
+		"does not mistake unsupported active %s styles for defaults",
+		(owner) => {
+			expect(
+				matchingComponentPreset(mergeConfig({ components: { [owner]: { style: "future" } } })),
+			).toBeUndefined();
+		},
+	);
+
+	it("ignores dormant Minimalist message styles, even future styles", () => {
+		const preset = getComponentPreset("minimalist");
+		for (const style of ["framed", "framed-copy-friendly", "compact", "labeled", "future"]) {
+			expect(
+				matchingComponentPreset(
+					mergeConfig({
+						components: { ...preset?.components, userMessages: { enabled: false, style } },
+					}),
+				)?.id,
+			).toBe("minimalist");
+		}
+	});
+});