Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/ephemlets/__tests__/panel.test.ts

Raw
import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
import { initTheme } from "@earendil-works/pi-coding-agent";
import {
	type Component,
	CURSOR_MARKER,
	type OverlayHandle,
	type OverlayOptions,
	stripTerminalSequences,
	type TUI,
	type TuiMouseEvent,
	visibleWidth,
} from "@earendil-works/pi-tui";
import { beforeAll, describe, expect, it, vi } from "vitest";
import { Look } from "../src/look.ts";
import { EphemletPanel, PanelHost, panelGeometry } from "../src/panel.ts";
import { EphemletStore } from "../src/store.ts";
import { plainTheme as theme } from "./theme.ts";

/** Column of a glyph in a plain-text row. */
const column = (line: string, text: string) =>
	visibleWidth(line.slice(0, line.indexOf(text)));
const lineWith = (lines: string[], text: string) =>
	lines.find((line) => line.includes(text)) ?? "";
const noActions = {
	changed() {},
	close() {},
	save() {},
	hide() {},
	answered() {},
};
beforeAll(() => initTheme("dark", false));

function mouse(
	x: number,
	y: number,
	type: TuiMouseEvent["type"] = "click",
): TuiMouseEvent {
	return {
		x,
		y,
		screenX: x,
		screenY: y,
		width: 60,
		height: 30,
		type,
		button: "left",
		shift: false,
		alt: false,
		ctrl: false,
	};
}
function handle(overrides: Partial<OverlayHandle> = {}): OverlayHandle {
	return {
		hide() {},
		setHidden() {},
		isHidden: () => false,
		focus() {},
		unfocus() {},
		isFocused: () => false,
		getBounds: () => undefined,
		...overrides,
	} as OverlayHandle;
}
function fixture() {
	const store = new EphemletStore(() => {});
	const terminal = { columns: 120, rows: 32 };
	const tui = { terminal, requestRender() {} } as unknown as TUI;
	const closed: string[] = [];
	const saved: string[] = [];
	let hidden = 0;
	const answered: string[] = [];
	const panel = new EphemletPanel(
		store,
		tui,
		theme,
		{
			changed: () => panel.refresh(),
			close: (id) => {
				closed.push(id);
				store.delete(id);
				panel.refresh();
			},
			save: (id) => saved.push(id),
			hide: () => {
				hidden++;
				store.view(store.selected, false);
			},
			answered: (id, field) => answered.push(`${id}/${field}`),
		},
		() => new Look(theme, undefined, "unicode"),
	);
	const put = (source: string) => {
		const record = store.put({ title: "Report", purpose: "Progress", source });
		store.view(record.id, true);
		panel.refresh();
		return record;
	};
	const host = (ctx: ExtensionContext) =>
		new PanelHost(
			store,
			() => ctx,
			noActions,
			() => "unicode",
		);
	return {
		store,
		terminal,
		tui,
		panel,
		put,
		host,
		closed,
		saved,
		answered,
		hidden: () => hidden,
	};
}
function widgetContext(tui: TUI, extra: Record<string, unknown> = {}) {
	let widget: (Component & { dispose?(): void }) | undefined;
	let placement: string | undefined;
	const ctx = {
		mode: "tui",
		ui: {
			setWidget(
				_key: string,
				factory: ((tui: TUI, theme: Theme) => typeof widget) | undefined,
				options?: { placement?: string },
			) {
				widget?.dispose?.();
				widget = factory?.(tui, theme);
				placement = options?.placement;
			},
			...extra,
		},
	} as unknown as ExtensionContext;
	return { ctx, widget: () => widget, placement: () => placement };
}

describe("ephemlet responsive overlay", () => {
	it("positions landscape right and portrait top, including small terminals", () => {
		expect(panelGeometry(120, 32)).toEqual({
			anchor: "top-right",
			width: 54,
			height: 28,
		});
		expect(panelGeometry(60, 50)).toEqual({
			anchor: "top-left",
			width: 60,
			height: 24,
		});
		expect(panelGeometry(2, 2)).toEqual({
			anchor: "top-left",
			width: 2,
			height: 1,
		});
	});
	it("renders Markdown within resized bounds and scrolls by keyboard", () => {
		const f = fixture();
		f.put(Array.from({ length: 60 }, (_, i) => `Line ${i}`).join("\n\n"));
		expect(f.panel.render(54).join("\n")).toContain("Line 0");
		f.panel.handleInput("\x1b[6~");
		expect(f.panel.render(54).join("\n")).not.toContain("Line 0");
		f.panel.handleInput("\x1b[5~");
		expect(f.panel.render(54).join("\n")).toContain("Line 0");
		f.terminal.columns = 30;
		f.terminal.rows = 50;
		const lines = f.panel.render(30);
		expect(lines.length).toBeLessThanOrEqual(24);
		expect(lines.every((line) => visibleWidth(line) <= 30)).toBe(true);
	});
	it("switches ephemlets by keyboard/mouse and hides without deleting", () => {
		const f = fixture();
		const first = f.put("first");
		const second = f.put("second");
		expect(f.panel.render(54).join("\n")).toContain("second");
		f.panel.handleInput("\x1b[1;3D");
		expect(f.store.selected).toBe(first.id);
		const header = f.panel.render(54)[0] ?? "";
		expect(header).toContain("●○");
		f.panel.handleMouse(mouse(column(header, "●○") + 1, 0));
		expect(f.store.selected).toBe(second.id);
		f.panel.handleInput("\x1b");
		expect(f.hidden()).toBe(1);
		expect(f.store.records.size).toBe(2);
	});
	it("saves and deletes by shortcut or header click", () => {
		const f = fixture();
		const record = f.put("report");
		const header = f.panel.render(54)[0] ?? "";
		expect(header).toContain("⤓ ✕");
		f.panel.handleInput("\x13");
		expect(f.saved).toEqual([record.id]);
		expect(f.store.records.size).toBe(1);
		f.panel.handleMouse(mouse(column(header, "⤓"), 0));
		expect(f.saved).toEqual([record.id, record.id]);
		f.panel.handleInput("\t");
		f.panel.handleInput("\r");
		expect(f.closed).toEqual([]);
		f.panel.handleInput("\x17");
		expect(f.closed).toEqual([record.id]);
		expect(f.store.records.size).toBe(0);
	});
	it("routes the delete icon cell to deletion, not Save", () => {
		const f = fixture();
		const record = f.put("report");
		const header = f.panel.render(54)[0] ?? "";
		f.panel.handleMouse(mouse(column(header, "✕"), 0));
		expect(f.closed).toEqual([record.id]);
		expect(f.saved).toEqual([]);
	});
	it("toggles checklist items by keyboard focus and click without scrolling away", () => {
		const f = fixture();
		const record = f.store.put({
			title: "Plan",
			purpose: "Steer",
			source: Array.from({ length: 40 }, (_, i) => `Line ${i}`).join("\n\n"),
			fields: [
				{
					id: "plan",
					type: "checklist",
					items: [
						{ id: "a", label: "Alpha\x1b[2J" },
						{ id: "b", label: "Beta", checked: true },
					],
				},
			],
		});
		f.store.view(record.id, true);
		f.panel.refresh();
		expect(f.panel.render(54).join("\n")).not.toContain("Alpha");
		expect(f.panel.render(54).join("\n")).not.toMatch(/instant|next turn/);
		f.panel.handleInput("\t");
		let frame = f.panel.render(54).join("\n");
		expect(frame).toContain("☐ Alpha");
		expect(frame).not.toContain("\x1b[2J");
		f.panel.handleInput(" ");
		f.panel.handleInput("\x1b[Z");
		f.panel.handleInput("\r");
		expect(f.store.get(record.id).answers).toEqual({
			plan: { a: true, b: false },
		});
		frame = f.panel.render(54).join("\n");
		expect(frame).toContain("◷ unread");
		// Unticking an item the agent had checked renders as a veto marked as yours.
		expect(lineWith(f.panel.render(54), "Beta")).toContain("☐ Beta  · you");
		expect(frame).toContain("1/2");
		const lines = f.panel.render(54);
		const row = lines.findIndex((line) => line.includes("Alpha"));
		f.panel.handleMouse(mouse(4, row));
		expect(f.store.get(record.id).answers["plan"]?.["a"]).toBe(false);
		f.store.seen(record.id);
		expect(f.panel.render(54)[0]).toContain("✔ read");
	});
	it("renders questions, keeps single answers exclusive and reports answers", () => {
		const f = fixture();
		const record = f.store.put({
			title: "Decide",
			purpose: "Ask",
			source: "# Decide",
			fields: [
				{
					id: "approach",
					type: "choice",
					label: "Approach",
					options: [
						{ id: "a", label: "Alpha" },
						{ id: "b", label: "Beta" },
					],
				},
				{ id: "ship", type: "confirm", label: "Ship it?" },
			],
		});
		f.store.view(record.id, true);
		f.panel.refresh();
		let lines = f.panel.render(54);
		expect(lineWith(lines, "Approach")).toContain("needs you");
		expect(lineWith(lines, "Ship it?")).toContain("needs you");
		// Delivery is visible before answering: confirm interrupts, choice waits a turn.
		expect(lineWith(lines, "Ship it?")).toMatch(/↯ instant $/);
		expect(lineWith(lines, "Approach")).toMatch(/⇢ next turn $/);
		expect(lines.join("\n")).toContain("○ Alpha");
		expect(lineWith(lines, "Yes")).toMatch(/^ {2}Yes {3}No /);
		f.panel.handleInput("\t");
		f.panel.handleInput(" ");
		f.panel.handleInput("\t");
		f.panel.handleInput(" ");
		f.panel.handleInput(" ");
		lines = f.panel.render(54);
		expect(lines.join("\n")).toContain("○ Alpha");
		expect(lines.join("\n")).toContain("◉ Beta");
		expect(lineWith(lines, "Approach")).not.toContain("needs you");
		expect(f.answered).toEqual([
			`${record.id}/approach`,
			`${record.id}/approach`,
		]);
		expect(lines[0]).toContain("◷ unread");
		f.store.sent.set(record.id, 2);
		expect(f.panel.render(54)[0]).toContain("✓ sent");
		// Confirm answers are clickable segments within one row.
		lines = f.panel.render(54);
		const row = lines.findIndex((line) => line.includes("Yes"));
		f.panel.handleMouse(mouse(column(lines[row] ?? "", "No"), row));
		expect(f.store.get(record.id).answers["ship"]).toEqual({
			yes: false,
			no: true,
		});
	});
	it("pins a needs-you marker for open questions out of view and jumps to them", () => {
		const f = fixture();
		const record = f.store.put({
			title: "Plan",
			purpose: "Steer",
			source: Array.from({ length: 40 }, (_, i) => `Line ${i}`).join("\n\n"),
			fields: [{ id: "ship", type: "confirm", label: "Ship it?" }],
		});
		f.store.view(record.id, true);
		let lines = f.panel.render(54);
		const marker = lines.findIndex((line) => line.includes("↓ 1 needs you"));
		expect(marker).toBe(lines.length - 2);
		expect(lines.join("\n")).not.toContain("Yes");
		f.panel.handleMouse(mouse(3, marker));
		lines = f.panel.render(54);
		expect(lines.join("\n")).toContain("Ship it?");
		expect(lines.join("\n")).not.toContain("\u2193");
		expect(lineWith(lines, "Yes")).toMatch(/Yes {3}No/);
		f.panel.handleInput(" ");
		expect(f.store.get(record.id).answers["ship"]).toEqual({
			yes: true,
			no: false,
		});
		expect(f.panel.render(54).join("\n")).not.toContain("needs you");
	});
	it("sends the first tab to an open question and starts new revisions at the top", () => {
		const f = fixture();
		const record = f.store.put({
			title: "Plan",
			purpose: "Steer",
			source: "# Plan",
			fields: [
				{ id: "plan", type: "checklist", items: [{ id: "a", label: "Alpha" }] },
				{
					id: "pick",
					type: "choice",
					options: [
						{ id: "x", label: "Xray" },
						{ id: "y", label: "Yankee" },
					],
				},
			],
		});
		f.store.view(record.id, true);
		f.panel.render(54);
		f.panel.handleInput("\t");
		f.panel.handleInput(" ");
		expect(f.store.get(record.id).answers).toEqual({
			pick: { x: true, y: false },
		});
		f.panel.handleInput("\x1b[6~");
		const next = f.store.put({
			...f.store.get(record.id),
			expectedRevision: 1,
			source: Array.from({ length: 40 }, (_, i) => `Line ${i}`).join("\n\n"),
		});
		expect(next.revision).toBe(2);
		expect(f.panel.render(54).join("\n")).toContain("Line 0");
	});
	it("edits text answers inline, submits on enter and cancels on escape", () => {
		const f = fixture();
		const record = f.store.put({
			title: "Ask",
			purpose: "Ask",
			source: "# Ask",
			fields: [
				{
					id: "why",
					type: "text",
					label: "Why?",
					placeholder: "One sentence",
				},
			],
		});
		f.store.view(record.id, true);
		let lines = f.panel.render(54);
		expect(lineWith(lines, "Why?")).toMatch(/needs you.*\u21e2 next turn $/);
		expect(lineWith(lines, "One sentence")).toContain("\u270e One sentence");
		f.panel.handleInput("\t");
		f.panel.handleInput("\r");
		expect(f.panel.render(54).at(-1)).toContain("enter submit");
		for (const key of "Faster") f.panel.handleInput(key);
		f.panel.handleInput("\x1b");
		expect(f.store.get(record.id).texts).toEqual({});
		expect(f.hidden()).toBe(0);
		f.panel.handleInput("\r");
		for (const key of "Faster") f.panel.handleInput(key);
		f.panel.handleInput("\r");
		expect(f.store.get(record.id).texts).toEqual({ why: "Faster" });
		expect(f.answered).toEqual([`${record.id}/why`]);
		lines = f.panel.render(54);
		expect(lineWith(lines, "Faster")).toContain("\u270e Faster");
		expect(lineWith(lines, "Why?")).not.toContain("needs you");
		f.store.waiting.set(record.id, new Set(["why"]));
		expect(lineWith(f.panel.render(54), "Why?")).toMatch(
			/\u29d7 agent waiting $/,
		);
	});
	it("wraps text answers and the inline editor inside painted rows without losing the cursor", () => {
		// Every painted segment is bracketed, so unpainted cells are visible leftovers.
		const painted = {
			...theme,
			style: (text: string) => `\u27e6${text}\u27e7`,
		} as unknown as Theme;
		const unpainted = (line: string) =>
			stripTerminalSequences(line.replace(/\u27e6[^\u27e7]*\u27e7/g, ""));
		const words = "wrap these words ".repeat(12);
		for (let length = 20; length <= 110; length++) {
			const store = new EphemletStore(() => {});
			const tui = {
				terminal: { columns: 120, rows: 32 },
				requestRender() {},
			} as unknown as TUI;
			const panel = new EphemletPanel(
				store,
				tui,
				painted,
				noActions,
				() => new Look(painted, undefined, "unicode"),
			);
			const record = store.put({
				title: "Ask",
				purpose: "Ask",
				source: "# Ask",
				fields: [{ id: "why", type: "text", label: "Why?" }],
			});
			store.view(record.id, true);
			panel.render(54);
			panel.handleInput("\t");
			panel.handleInput("\r");
			for (const key of words.slice(0, length)) panel.handleInput(key);
			const editing = panel.render(54);
			const rows = editing.filter((line) => line.includes("\u270e"));
			const field = editing.slice(
				editing.indexOf(rows[0] ?? ""),
				editing.indexOf(rows[0] ?? "") + Math.ceil(length / 40) + 2,
			);
			expect(field.some((line) => line.includes(CURSOR_MARKER))).toBe(true);
			expect(
				field.some((line) =>
					/\x1b_pi:fc\x07[^\x1b]+\x1b_pi:\/fc\x07/.test(line),
				),
			).toBe(true);
			for (const line of field) {
				expect(
					visibleWidth(line.replace(/[\u27e6\u27e7]/g, "")),
				).toBeLessThanOrEqual(54);
				if (line.includes("\u27e6")) expect(unpainted(line)).toBe("");
			}
			panel.handleInput("\r");
			const text = panel
				.render(54)
				.map((line) =>
					stripTerminalSequences(line).replace(/[\u27e6\u27e7\u2502]/g, ""),
				)
				.join(" ");
			expect(text.replace(/\s+/g, " ")).toContain(
				words.slice(0, length).trim().replace(/\s+/g, " "),
			);
			expect(text).not.toContain("\u2026");
		}
	});

	it("tracks hover only over answer rows and re-renders only on change", () => {
		const f = fixture();
		const record = f.store.put({
			title: "Plan",
			purpose: "Steer",
			source: "# Plan",
			fields: [
				{ id: "plan", type: "checklist", items: [{ id: "a", label: "Alpha" }] },
			],
		});
		f.store.view(record.id, true);
		const lines = f.panel.render(54);
		const row = lines.findIndex((line) => line.includes("Alpha"));
		expect(f.panel.handleMouse(mouse(4, row, "move"))).toEqual({
			handled: true,
			render: true,
		});
		expect(f.panel.handleMouse(mouse(6, row, "move"))).toEqual({
			handled: true,
		});
		expect(f.panel.handleMouse(mouse(4, 0, "move"))).toEqual({
			handled: true,
			render: true,
		});
		expect(f.store.get(record.id).answerRevision).toBe(0);
	});
	it("returns only actually rendered bounded views and marks revisions stale", () => {
		const f = fixture();
		const record = f.put("# Current\nRendered report");
		expect(f.panel.getView(record.id)).toEqual({
			available: false,
			reason: "Never rendered",
		});
		f.panel.render(54);
		const view = f.panel.getView(record.id);
		expect(view).toMatchObject({
			available: true,
			revision: record.revision,
			width: 54,
			stale: false,
		});
		if (view.available) expect(view.plainText).toContain("Rendered report");
		f.store.put({ ...record, expectedRevision: 1, source: "changed" });
		expect(f.panel.getView(record.id)).toMatchObject({
			available: true,
			stale: true,
		});
	});
	it("keeps compact presence above editor without mounting an overlay", () => {
		const f = fixture();
		const record = f.put("report");
		f.store.view(record.id, false);
		const showOverlay = vi.fn();
		f.tui.showOverlay = showOverlay;
		const w = widgetContext(f.tui);
		const host = f.host(w.ctx);
		try {
			host.refresh();
			expect(showOverlay).not.toHaveBeenCalled();
			expect(w.placement()).toBe("aboveEditor");
			expect(w.widget()?.render(60).join("\n")).toBe(
				" ● Ephemlets 1 · alt+e expand",
			);
			f.store.put({
				title: "Ask",
				purpose: "Ask",
				source: "?",
				fields: [{ id: "go", type: "confirm", label: "Go?" }],
			});
			expect(w.widget()?.render(60).join("\n")).toBe(
				" ● Ephemlets 2  1 needs you  · alt+e expand",
			);
			expect(host.getView(record.id)).toEqual({
				available: false,
				reason: "Never rendered",
			});
		} finally {
			host.dispose();
		}
	});
	it("cleans failed widget registration and allows retry", () => {
		const f = fixture();
		f.put("report");
		const mounted: Component[] = [];
		const hide = vi.fn();
		const notify = vi.fn();
		let calls = 0;
		f.tui.showOverlay = (component) => {
			mounted.push(component);
			return handle({ hide });
		};
		const ctx = {
			mode: "tui",
			ui: {
				notify,
				setWidget: (
					_key: string,
					factory: ((tui: TUI, theme: Theme) => unknown) | undefined,
				) => {
					if (!factory) return;
					factory(f.tui, theme);
					if (++calls === 1) throw new Error("Widget registration failed");
				},
			},
		} as unknown as ExtensionContext;
		const host = f.host(ctx);
		try {
			host.refresh();
			expect(notify).toHaveBeenCalledWith(
				"Ephemlet panel: Error: Widget registration failed",
				"error",
			);
			expect(hide).toHaveBeenCalledTimes(1);
			expect(mounted[0]?.render(54)).toEqual([]);
			host.refresh();
			expect(calls).toBe(2);
			expect(mounted[1]?.render(54).length).toBeGreaterThan(0);
			host.dispose();
			expect(mounted[1]?.render(54)).toEqual([]);
			expect(hide).toHaveBeenCalledTimes(2);
		} finally {
			host.dispose();
		}
	});
	it("hides through overlay handle rather than deleting/reloading", () => {
		const f = fixture();
		f.put("report");
		let isHidden = false;
		let options: OverlayOptions | undefined;
		f.tui.showOverlay = (_component, nextOptions) => {
			options = nextOptions;
			return handle({
				setHidden(value: boolean) {
					isHidden = value;
				},
				isHidden: () => isHidden,
			});
		};
		const w = widgetContext(f.tui);
		const setWidget = vi.spyOn(w.ctx.ui, "setWidget");
		const host = f.host(w.ctx);
		try {
			host.refresh();
			f.store.view(f.store.selected, false);
			host.refresh();
			expect(isHidden).toBe(true);
			f.store.view(f.store.selected, true);
			host.refresh(true);
			expect(isHidden).toBe(false);
			expect(setWidget).toHaveBeenCalledTimes(1);
			expect(options?.anchor).toBe("top-right");
			f.terminal.columns = 40;
			f.terminal.rows = 50;
			expect(options?.anchor).toBe("top-left");
			expect(options?.width).toBe(40);
		} finally {
			host.dispose();
		}
	});
});