@selesai/code 0.9.15 → 0.10.0

package/dist/extensions/pi-zentui/test/completion-menu.test.ts

@@ -0,0 +1,265 @@
+import { stripVTControlCharacters } 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 {
+	applyOwnedSurfaceBackground,
+	isNativeCompletionCountRow,
+	omitTrailingNativeCompletionCountRow,
+	renderCompletionPalette,
+	renderCompletionRows,
+	replaceNativeSelectedPrefix,
+} from "../extensions/zentui/completion-menu";
+
+function theme(): Theme {
+	return {
+		bg: (_color: string, text: string) => `\x1b[48;5;234m${text}\x1b[49m`,
+		getBgAnsi: () => "\x1b[48;5;234m",
+	} as unknown as Theme;
+}
+
+function plain(value: string): string {
+	return stripVTControlCharacters(value);
+}
+
+function terminalWidth(value: string): number {
+	return visibleWidth(value.replace(/\u009b([0-?]*[ -/]*[@-~])/g, "\x1b[$1"));
+}
+
+describe("completion menu surfaces", () => {
+	it("renders a transparent full-width palette shell without a results header or native count row", () => {
+		const rows = renderCompletionPalette({
+			lines: ["\x1b[38;5;39m→ settings\x1b[0m", "  files", "\x1b[90m  (1/47)  \x1b[0m"],
+			width: 40,
+			theme: theme(),
+			renderSeparator: (text) => `\x1b[90m${text}\x1b[0m`,
+			ownedBackground: false,
+		});
+		expect(rows.map(plain)).toEqual([
+			"  settings                              ",
+			"  files                                 ",
+			"────────────────────────────────────────",
+			" ↑↓ Navigate   Enter Use   Esc Close    ",
+		]);
+		expect(rows.join("\n")).not.toContain("Results");
+		expect(rows.join("\n")).not.toContain("\x1b[48;5;234m");
+		expect(rows[0]).toContain("  \x1b[38;5;39msettings");
+		expect(rows.slice(0, 2).every((row) => visibleWidth(row) === 40)).toBe(true);
+	});
+
+	it("preserves native embedded row backgrounds in a transparent palette", () => {
+		const rows = renderCompletionPalette({
+			lines: ["\x1b[48;5;52m→ warning\x1b[49m"],
+			width: 24,
+			theme: theme(),
+			renderSeparator: (text) => text,
+			ownedBackground: false,
+		});
+		expect(rows[0]).toContain("\x1b[48;5;52m");
+		expect(rows.join("\n")).not.toContain("\x1b[48;5;234m");
+	});
+
+	it.each([
+		[
+			"ESC CSI",
+			"\x1b[48;5;52m  warning\x1b[49m next\x1b[0m",
+			"\x1b[48;5;52m",
+			"\x1b[49m\x1b[48;5;234m next",
+			"\x1b[0m\x1b[48;5;234m",
+		],
+		[
+			"C1 CSI",
+			"\u009b48;5;52m  warning\u009b49m next\u009b0m",
+			"\u009b48;5;52m",
+			"\u009b49m\x1b[48;5;234m next",
+			"\u009b0m\x1b[48;5;234m",
+		],
+	] as const)(
+		"restores owned background after %s native resets while retaining embedded backgrounds",
+		(_name, embedded, nativeBackground, restoredDefault, restoredReset) => {
+			const [row] = renderCompletionRows({
+				lines: [embedded],
+				width: 24,
+				theme: theme(),
+				selectedPrefix: "  ",
+				ownedBackground: true,
+			});
+			expect(row).toContain(nativeBackground);
+			expect(row).toContain(restoredDefault);
+			expect(row).toContain(restoredReset);
+			expect(row).toMatch(/(?:\x1b\[0m|\u009b0m)\x1b\[48;5;234m +\x1b\[49m$/);
+			expect(terminalWidth(row ?? "")).toBe(24);
+		},
+	);
+
+	it.each([
+		["ESC SGR", "\x1b[1;38;5;39m→ help\x1b[0m", "  \x1b[1;38;5;39mhelp\x1b[0m"],
+		["C1 SGR", "\u009b1;38;5;39m→ help\u009b0m", "  \u009b1;38;5;39mhelp\u009b0m"],
+	] as const)(
+		"changes a native selected prefix preceded by %s only",
+		(_name, selected, expected) => {
+			expect(replaceNativeSelectedPrefix(selected, "  ")).toBe(expected);
+		},
+	);
+
+	it.each([
+		["cursor movement", "\x1b[1G→ help"],
+		["erase", "\x1b[2K→ help"],
+		["C1 erase", "\u009b2K→ help"],
+		["mode", "\x1b[?25l→ help"],
+		["private m-final CSI", "\x1b[>4;2m→ help"],
+		["private C1 m-final CSI", "\u009b>4;2m→ help"],
+		["SGR followed by private m-final CSI", "\x1b[1m\x1b[>4;2m→ help"],
+		["SGR followed by cursor movement", "\x1b[1m\x1b[1G→ help"],
+		["OSC", "\x1b]8;;https://example.com\x07→ help\x1b]8;;\x07"],
+	] as const)("leaves a selected-looking row with leading %s unchanged", (_name, line) => {
+		expect(replaceNativeSelectedPrefix(line, "  ")).toBe(line);
+	});
+
+	it.each([
+		["ESC reset plus foreground", "\x1b[0;39m", true],
+		["ESC foreground plus background reset", "\x1b[31;49m", true],
+		["ESC reset then explicit background", "\x1b[0;41m", false],
+		["ESC background then reset", "\x1b[41;49m", true],
+		["ESC extended black background", "\x1b[0;48;2;0;0;0m", false],
+		["ESC colon extended black background", "\x1b[0;48:2::0:0:0m", false],
+		["ESC extended background then reset", "\x1b[48;5;0;49m", true],
+		["C1 reset plus foreground", "\u009b0;39m", true],
+		["C1 reset then explicit background", "\u009b0;101m", false],
+		["C1 background then reset", "\u009b101;49m", true],
+	] as const)("respects ordered background semantics for %s", (_name, sequence, restores) => {
+		const background = "\x1b[48;5;234m";
+		const primary = applyOwnedSurfaceBackground(theme(), `before${sequence}tail   `);
+		expect(primary).toContain(sequence);
+		expect(primary.includes(`${sequence}${background}tail`)).toBe(restores);
+		expect(terminalWidth(primary)).toBe(13);
+
+		const fallbackTheme = {
+			...theme(),
+			getBgAnsi() {
+				throw new Error("unavailable");
+			},
+		} as unknown as Theme;
+		const fallback = applyOwnedSurfaceBackground(fallbackTheme, `before${sequence}tail   `);
+		expect(fallback).toContain(sequence);
+		expect(fallback.includes(`${sequence}${background}tail`)).toBe(restores);
+		expect(terminalWidth(fallback)).toBe(13);
+	});
+
+	it.each(["\u009b0m", "\u009bm", "\u009b49m"])(
+		"reapplies the theme.bg fallback after C1 reset %j through trailing padding",
+		(reset) => {
+			const fallbackTheme = {
+				...theme(),
+				getBgAnsi() {
+					throw new Error("unavailable");
+				},
+			} as unknown as Theme;
+			const row = applyOwnedSurfaceBackground(fallbackTheme, `item${reset}█   `);
+			expect(row).toContain(`${reset}\x1b[48;5;234m█   \x1b[49m`);
+		},
+	);
+
+	it.each(["\u009b0m", "\u009bm", "\u009b49m"])(
+		"reapplies getBgAnsi background after direct C1 reset %j",
+		(reset) => {
+			const row = applyOwnedSurfaceBackground(theme(), `item${reset}tail`);
+			expect(row).toContain(`${reset}\x1b[48;5;234mtail`);
+		},
+	);
+
+	it("leaves combined C1 resets and embedded backgrounds authoritative in transparent rows", () => {
+		const embedded = "\u009b48;5;52m→ warning\u009b31;49m next\u009b0;39m";
+		const [row] = renderCompletionRows({
+			lines: [embedded],
+			width: 20,
+			theme: theme(),
+			selectedPrefix: "  ",
+			ownedBackground: false,
+		});
+		expect(row).toContain("\u009b48;5;52m");
+		expect(row).toContain("\u009b31;49m next\u009b0;39m");
+		expect(row).not.toContain("\x1b[48;5;234m");
+		expect(terminalWidth(row ?? "")).toBe(20);
+	});
+
+	it("preserves SGR-only selection replacement and fails open for control CSI in a palette", () => {
+		const c1Selected = "\u009b1;38;5;39m→ settings\u009b0m";
+		const cursorControlled = "\x1b[2K→ unsafe";
+		const c1CursorControlled = "\u009b2K→ c1-unsafe";
+		const rows = renderCompletionPalette({
+			lines: [c1Selected, cursorControlled, c1CursorControlled],
+			width: 24,
+			theme: theme(),
+			renderSeparator: (text) => text,
+			ownedBackground: false,
+		});
+		expect(rows[0]).toContain("  \u009b1;38;5;39msettings\u009b0m");
+		expect(rows[1]).toContain(cursorControlled);
+		expect(rows[1]).not.toContain(`  ${cursorControlled}`);
+		expect(rows[2]).toContain(c1CursorControlled);
+		expect(rows[2]).not.toContain(`  ${c1CursorControlled}`);
+	});
+
+	it("omits only a trailing standalone native count row", () => {
+		expect(isNativeCompletionCountRow(" \x1b[90m(6/47)\x1b[0m ")).toBe(true);
+		expect(isNativeCompletionCountRow("(6/47) details")).toBe(false);
+		expect(isNativeCompletionCountRow("\x1b]8;;https://example.com\x07(6/47)\x1b]8;;\x07")).toBe(
+			false,
+		);
+		expect(
+			omitTrailingNativeCompletionCountRow(["  (1/47)", "  item", "\u009b90m (2/47) \u009b0m"]),
+		).toEqual(["  (1/47)", "  item"]);
+		expect(omitTrailingNativeCompletionCountRow(["  item", "  (1/47) details"])).toEqual([
+			"  item",
+			"  (1/47) details",
+		]);
+	});
+
+	it("keeps Unicode and combining rows width-safe", () => {
+		const rows = renderCompletionRows({
+			lines: ["→ é\u0301dit 😀 界"],
+			width: 9,
+			theme: theme(),
+			selectedPrefix: "  ",
+			ownedBackground: true,
+		});
+		expect(plain(rows[0] ?? "")).toContain("  é\u0301dit");
+		expect(visibleWidth(rows[0] ?? "")).toBe(9);
+	});
+
+	it("compacts help and fails safely at narrow widths", () => {
+		const compact = renderCompletionPalette({
+			lines: ["→ item"],
+			width: 18,
+			theme: theme(),
+			renderSeparator: (text) => text,
+			ownedBackground: false,
+		});
+		expect(compact.map(plain)).toEqual([
+			"  item            ",
+			"──────────────────",
+			" ↑↓   Enter   Esc ",
+		]);
+		const tiny = renderCompletionPalette({
+			lines: ["→ item"],
+			width: 2,
+			theme: theme(),
+			renderSeparator: (text) => text,
+			ownedBackground: false,
+		});
+		expect(tiny.map(plain)).toEqual(["  ", "──"]);
+	});
+
+	it("falls back without corruption when theme background APIs fail", () => {
+		const unavailable = {
+			getBgAnsi() {
+				throw new Error("unavailable");
+			},
+			bg() {
+				throw new Error("unavailable");
+			},
+		} as unknown as Theme;
+		expect(applyOwnedSurfaceBackground(unavailable, "safe\x1b[0m text")).toBe("safe\x1b[0m text");
+	});
+});