gentle-pi 2.5.0 → 2.6.0

package/tests/shell-sidebar.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { TUI } from "@earendil-works/pi-tui";
+import { sidebarPart, sidebarState } from "../lib/shell-sidebar.ts";
+
+const host = (terminal?: object) => ({ terminal }) as TUI;
+const component = () => ({ render: (_width = 80) => ["bottom"], invalidate() {} });
+
+test("unsupported hosts retain the original bottom widget and disposal", () => {
+	for (const tui of [host(), host(null as unknown as object)]) {
+		let disposed = 0;
+		const bottom = { ...component(), dispose() { disposed++; } };
+		const part = sidebarPart(tui, "todo", bottom);
+		assert.equal(part, bottom);
+		assert.deepEqual(part.render(), ["bottom"]);
+		part.dispose();
+		assert.equal(disposed, 1);
+	}
+});
+
+test("terminal state survives host replacement without leaking across terminals", () => {
+	const terminal = {};
+	assert.equal(sidebarState(host(terminal)), sidebarState(host(terminal)));
+	assert.notEqual(sidebarState(host(terminal)), sidebarState(host({})));
+});
+
+test("bottom paint is suppressed only while the sidebar owns the host", () => {
+	const tui = host({});
+	const state = sidebarState(tui);
+	const part = sidebarPart(tui, "todo", component());
+	state.active = true;
+	assert.deepEqual(part.render(80), ["bottom"]);
+	state.ownsHost = () => true;
+	assert.deepEqual(part.render(80), []);
+	state.active = false;
+	assert.deepEqual(part.render(80), ["bottom"]);
+});
+
+test("disposing an old part preserves its replacement and releases its bottom", () => {
+	const tui = host({});
+	let disposed = 0;
+	const first = sidebarPart(tui, "todo", { ...component(), dispose() { disposed++; } });
+	const replacement = component();
+	const second = sidebarPart(tui, "todo", replacement);
+	first.dispose?.();
+	assert.equal(disposed, 1);
+	assert.equal(sidebarState(tui).parts.get("todo"), replacement);
+	(second as typeof second & { dispose?(): void }).dispose?.();
+	assert.equal(sidebarState(tui).parts.size, 0);
+});

package/tests/shell-todo.test.ts

@@ -134,7 +134,7 @@ test("renderTodoCard draws the framed list with status glyphs and keeps every li
 	const lines = renderTodoCard(seeded(), plainTheme, 60, { collapsed: false, staleTurns: 0, collapseKey: "ctrl+shift+t" });
 	for (const line of lines) assert.equal(visibleWidth(line), 60, `"${stripAnsi(line)}" is not 60 wide`);
 	const plain = lines.map(stripAnsi);
-	assert.match(plain[0], /^╭─ ❀ Todos · 1 of 3 ─+╮$/);
+	assert.match(plain[0], /^╭─ ❀ Todos ▾ Collapse · 1 of 3 ─+ ctrl\+shift\+t collapse ╮$/);
 	assert.match(plain[1], /^│ ✓ ~Add quiet tool rendering~ +│$/);
 	assert.match(plain[2], /^│ ◐ Fix quiet tools conflict · fixing conflict +│$/);
 	assert.match(plain[3], /^│ ○ Show git bash tails +│$/);
@@ -146,7 +146,7 @@ test("renderTodoCard folds a long list: done tasks become one row and the open o
 	const state = applyTodo(emptyTodo(), { action: "write", tasks }, 1).state;
 	const plain = renderTodoCard(state, plainTheme, 60, { collapsed: false, staleTurns: 0 }).map(stripAnsi);
 	assert.equal(plain.length, 14, "top rule, twelve rows, bottom rule");
-	assert.match(plain[0], /Todos · 25 of 40/);
+	assert.match(plain[0], /Todos ▾ Collapse · 25 of 40/);
 	assert.match(plain[1], /^│ ✓ 25 done +│$/);
 	assert.match(plain[2], /^│ ◐ Task 26 +│$/);
 	assert.match(plain[11], /^│ ○ Task 35 +│$/);
@@ -157,14 +157,103 @@ test("renderTodoCard folds a long list: done tasks become one row and the open o
 	assert.match(folded[1], /^│ ✓ 40 done +│$/);
 });
 
-test("renderTodoCard marks a stale list in the top rule and collapses to the task in progress", () => {
-	const stale = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 2, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
-	assert.match(stale[0], /^╭─ ❀ Todos · 1 of 3 ─+ stale · 2 turns ╮$/);
-	const collapsed = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
-	assert.equal(collapsed.length, 3);
-	assert.match(collapsed[0], /^╭─ ❀ Todos · 1 of 3 ─+ ctrl\+shift\+t expand ╮$/);
-	assert.match(collapsed[1], /^│ ◐ Fix quiet tools conflict · fixing conflict +│$/);
-	const idle = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "Only pending" }] }, 1).state;
-	assert.match(renderTodoCard(idle, plainTheme, 70, { collapsed: true, staleTurns: 0 }).map(stripAnsi)[1], /^│ ○ 1 open +│$/);
+test("renderTodoCard keeps the configured collapse shortcut in the header while stale state remains visible", () => {
+	const freshExpanded = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(freshExpanded[0], /^╭─ ❀ Todos ▾ Collapse · 1 of 3 ─+ ctrl\+shift\+t collapse ╮$/);
+
+	const freshCollapsed = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.equal(freshCollapsed.length, 3);
+	assert.match(freshCollapsed[0], /^╭─ ❀ Todos ▸ Expand · 1 of 3 ─+ ctrl\+shift\+t expand ╮$/);
+	assert.match(freshCollapsed[1], /^│ ◐ Fix quiet tools conflict · fixing conflict +│$/);
+
+	const staleExpanded = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 2, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(staleExpanded[0], /^╭─ ❀ Todos ▾ Collapse · 1 of 3 ─+ ctrl\+shift\+t collapse ╮$/);
+	assert.match(staleExpanded[1], /^│ stale · 2 turns +│$/);
+
+	const staleCollapsed = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 2, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(staleCollapsed[0], /^╭─ ❀ Todos ▸ Expand · 1 of 3 ─+ ctrl\+shift\+t expand ╮$/);
+	assert.match(staleCollapsed[1], /^│ stale · 2 turns +│$/);
+	assert.match(staleCollapsed[2], /^│ ◐ Fix quiet tools conflict · fixing conflict +│$/);
+
+	const fallback = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "Finished first", status: "done" }, { title: "First pending" }, { title: "Later pending" }] }, 1).state;
+	assert.match(renderTodoCard(fallback, plainTheme, 70, { collapsed: true, staleTurns: 0 }).map(stripAnsi)[1], /^│ ○ First pending +│$/);
+
+	const activeAfterPending = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "Pending first" }, { title: "Active second", status: "in_progress" }, { title: "Pending third" }] }, 1).state;
+	assert.match(renderTodoCard(activeAfterPending, plainTheme, 70, { collapsed: true, staleTurns: 0 }).map(stripAnsi)[1], /^│ ◐ Active second +│$/);
 	assert.deepEqual(renderTodoCard(emptyTodo(), plainTheme, 70, { collapsed: false, staleTurns: 0 }), []);
 });
+
+test("renderTodoCard keeps English controls visible and falls back to their icons at narrow widths", () => {
+	const expanded = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(expanded[0], /Todos ▾ Collapse/);
+	assert.match(expanded[0], /ctrl\+shift\+t collapse/);
+	const collapsed = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(collapsed[0], /Todos ▸ Expand/);
+	for (const [collapsedState, icon] of [[false, "▾"], [true, "▸"]] as const) {
+		const line = renderTodoCard(seeded(), plainTheme, 16, { collapsed: collapsedState, staleTurns: 0, collapseKey: "ctrl+shift+t" })[0]!;
+		assert.match(stripAnsi(line), new RegExp(`Todos ${icon}`));
+		assert.equal(visibleWidth(line), 16);
+	}
+});
+
+test("completed titles strike only title cells across wrapped lines, never padding or rails", () => {
+	const theme = {
+		fg: (_color: string, text: string) => `\x1b[32m${text}\x1b[39m`,
+		strikethrough: (text: string) => `\x1b[9m${text}\x1b[29m`,
+	};
+	const state = applyTodo(emptyTodo(), { action: "write", tasks: [
+		{ title: "Alpha beta gamma delta epsilon", status: "done" },
+		{ title: "Pending", status: "pending" },
+	] }, 1).state;
+	for (const width of [12, 20, 60]) {
+		const lines = renderTodoCard(state, theme, width, { collapsed: false, staleTurns: 0 });
+		let struckLetters = "";
+		for (const line of lines) {
+			let strike = false, column = 0;
+			const plain = stripAnsi(line);
+			const titleEnd = plain.slice(0, -1).trimEnd().length;
+			for (const token of line.match(/\x1b\[[\d;]*m|[^\x1b]/gu) ?? []) {
+				if (token.startsWith("\x1b")) {
+					for (const code of token.slice(2, -1).split(";").map(Number)) {
+						if (code === 0 || code === 29) strike = false;
+						if (code === 9) strike = true;
+					}
+				} else {
+					if (column < 2 || column >= titleEnd || /[│╭╮╰╯─✓]/u.test(token)) assert.equal(strike, false, `struck frame/padding: ${JSON.stringify(line)}`);
+					if (strike && /[A-Za-z]/.test(token)) struckLetters += token;
+					column += visibleWidth(token);
+				}
+			}
+			assert.equal(strike, false, "SGR 9 must close before the host appends padding");
+			assert.equal(visibleWidth(line), width);
+		}
+		assert.equal(struckLetters, "Alphabetagammadeltaepsilon");
+	}
+});
+
+test("renderTodoCard keeps stale indicators and collapse hints in scrollable lists", () => {
+	const tasks = Array.from({ length: 40 }, (_, index) => ({ title: `Task ${index + 1}`, status: index < 25 ? "done" : "pending" }));
+	const state = applyTodo(emptyTodo(), { action: "write", tasks }, 1).state;
+	const lines = renderTodoCard(state, plainTheme, 70, { scrollable: true, collapsed: false, staleTurns: 2, collapseKey: "alt+t" }).map(stripAnsi);
+	assert.equal(lines.length, 43, "top rule, stale row, every task, bottom rule");
+	assert.match(lines[0], /^╭─ ❀ Todos ▾ Collapse · 25 of 40 ─+ alt\+t collapse ╮$/);
+	assert.match(lines[1], /^│ stale · 2 turns +│$/);
+	assert.match(lines[2], /^│ ✓ ~Task 1~ +│$/);
+	assert.match(lines[41], /^│ ○ Task 40 +│$/);
+	for (const line of lines) assert.equal(visibleWidth(line), 70);
+});
+
+test("renderTodoCard uses custom shortcuts, omits disabled shortcuts, and remains width-safe when hints cannot fit", () => {
+	const custom = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 2, collapseKey: "alt+t" }).map(stripAnsi);
+	assert.match(custom[0], /alt\+t collapse/);
+	assert.match(custom[1], /stale · 2 turns/);
+
+	const disabled = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 2 }).map(stripAnsi);
+	assert.doesNotMatch(disabled[0], /(?:collapse|expand|ctrl\+shift\+t)/);
+	assert.match(disabled[1], /stale · 2 turns/);
+
+	for (const width of [0, 1, 2, 3, 4, 5, 8, 16]) {
+		const lines = renderTodoCard(seeded(), plainTheme, width, { collapsed: false, staleTurns: 2, collapseKey: "ctrl+shift+t" });
+		for (const line of lines) assert.equal(visibleWidth(line), width, `"${stripAnsi(line)}" is not ${width} wide`);
+	}
+});

package/tests/startup-banner.test.ts

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { syncBuiltinESMExports } from "node:module";
+import fs from "node:fs/promises";
+import startup, { readGitBranch } from "../extensions/startup-banner.ts";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+
+test("startup branch lookup uses direct git argv and hides its Windows child", async () => {
+	const calls: Array<{ command: string; args: readonly string[]; options: Record<string, unknown> }> = [];
+	const run = ((command: string, args: readonly string[], options: Record<string, unknown>, callback: (error: Error | null, stdout: string) => void) => {
+		calls.push({ command, args, options });
+		callback(null, "main\n");
+	}) as typeof import("node:child_process").execFile;
+	assert.equal(await readGitBranch("/repo with spaces & metacharacters", run), "On branch main");
+	assert.deepEqual(calls, [{
+		command: "git",
+		args: ["-C", "/repo with spaces & metacharacters", "branch", "--show-current"],
+		options: { encoding: "utf8", shell: false, windowsHide: true },
+    }]);
+});
+
+test("startup banner keeps animating after invalidate and cleans up on dispose", async (t) => {
+	t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+	t.mock.method(fs, "readFile", async () => JSON.stringify({ showRose: true, showTextLogo: true, color: "pink" }));
+	syncBuiltinESMExports();
+	t.after(() => { t.mock.restoreAll(); syncBuiltinESMExports(); });
+	const argv = process.argv;
+	process.argv = ["node"];
+	t.after(() => { process.argv = argv; });
+	for (const [key, value] of [["rows", 40], ["columns", 160]] as const) {
+		const descriptor = Object.getOwnPropertyDescriptor(process.stdout, key);
+		Object.defineProperty(process.stdout, key, { configurable: true, writable: true, value });
+		t.after(() => descriptor ? Object.defineProperty(process.stdout, key, descriptor) : Reflect.deleteProperty(process.stdout, key));
+	}
+	let start: Function;
+	let shutdown: Function;
+	let header: { render(width: number): string[]; invalidate(): void; dispose(): void };
+	let renders = 0;
+	startup({ on: (name: string, fn: Function) => {
+		if (name === "session_start") start = fn;
+		if (name === "session_shutdown") shutdown = fn;
+	}, registerCommand() {}, getCommands: () => [], getAllTools: () => [] } as unknown as ExtensionAPI);
+	await start!({}, { hasUI: true, cwd: "/fixture", ui: { setHeader: (factory: Function) => {
+		header = factory({ requestRender() { renders++; } }, { fg: (_role: string, text: string) => text });
+	} } });
+	t.mock.timers.tick(50);
+	const afterBoot = renders;
+	t.mock.timers.tick(25);
+	assert.ok(renders > afterBoot, "animation timer requests renders");
+	header!.invalidate();
+	const afterInvalidate = renders;
+	t.mock.timers.tick(25);
+	assert.ok(renders > afterInvalidate, "invalidate() must not stop the animation timer");
+	header!.dispose();
+	const afterDispose = renders;
+	t.mock.timers.tick(25);
+	assert.equal(renders, afterDispose, "dispose() stops the animation timer");
+	shutdown!();
+	t.mock.timers.tick(25);
+	assert.equal(renders, afterDispose, "session_shutdown cleanup stays idle");
+});
+
+// Drive the real header factory; background git/home reads never run.
+for (const showRose of [false, true]) for (const showTextLogo of [false, true]) {
+	test(`startup art respects rose=${showRose}, logo=${showTextLogo} and cyan palette`, async (t) => {
+		t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+		t.mock.method(fs, "readFile", async () => JSON.stringify({ showRose, showTextLogo, color: "cyan" }));
+		syncBuiltinESMExports();
+		t.after(() => { t.mock.restoreAll(); syncBuiltinESMExports(); });
+		const argv = process.argv;
+		process.argv = ["node"];
+		t.after(() => { process.argv = argv; });
+		for (const [key, value] of [["rows", 40], ["columns", 160]] as const) {
+			const descriptor = Object.getOwnPropertyDescriptor(process.stdout, key);
+			Object.defineProperty(process.stdout, key, { configurable: true, writable: true, value });
+			t.after(() => descriptor ? Object.defineProperty(process.stdout, key, descriptor) : Reflect.deleteProperty(process.stdout, key));
+		}
+		let start: Function;
+		let shutdown: Function;
+		let header: { render(width: number): string[]; dispose(): void };
+		const writes: string[] = [];
+		startup({ on: (name: string, fn: Function) => {
+			if (name === "session_start") start = fn;
+			if (name === "session_shutdown") shutdown = fn;
+		}, registerCommand() {}, getCommands: () => [], getAllTools: () => [] } as unknown as ExtensionAPI);
+		const write = t.mock.method(process.stdout, "write", (text: string) => { writes.push(String(text)); return true; });
+		await start!({}, { hasUI: true, cwd: "/fixture", ui: { setHeader: (factory: Function) => {
+			header = factory({ requestRender() {} }, { fg: (_role: string, text: string) => text });
+		} } });
+		t.mock.timers.tick(50);
+		try {
+			for (const width of [40, 80, 160]) {
+				const lines = header!.render(width);
+				assert.ok(lines.every((line) => visibleWidth(line) <= width));
+				const text = stripAnsi(lines.join("\n"));
+				assert.match(text, /GIT:/);
+				assert.match(text, /PATH:/);
+				if (width === 160) {
+					assert.equal(/[\u2800-\u28ff]/.test(text), showRose);
+					assert.equal(/[▒▄▀█]/.test(text), showTextLogo);
+				}
+				assert.match(lines.join("\n"), /\x1b\[38;2;85;170;205m/, "startup labels use the saved cyan palette");
+			}
+			// Cancel pending context reads before advancing the resize clock.
+			t.mock.timers.reset();
+			t.mock.timers.enable({ apis: ["setTimeout", "Date"], now: Date.now() + 1000 });
+			process.stdout.rows = 10;
+			process.stdout.emit("resize");
+			t.mock.timers.tick(150);
+			assert.deepEqual(header!.render(80), []);
+			process.stdout.rows = 25;
+			process.stdout.columns = 80;
+			process.stdout.emit("resize");
+			t.mock.timers.tick(150);
+			const minimal = stripAnsi(header!.render(80).join("\n"));
+			assert.doesNotMatch(minimal, /[\u2800-\u28ff]/);
+			assert.equal(/[▒▄▀█]/.test(minimal), showTextLogo);
+			assert.deepEqual(writes, [], "Pi owns stdout during startup and resize");
+		} finally {
+			shutdown!();
+			write.mock.restore();
+		}
+	});
+}

package/tests/telemetry-trigger.test.ts

@@ -73,7 +73,7 @@ test("shouldTriggerTelemetry: pure predicate table", () => {
 	}
 });
 
-test("spawnTelemetryTrigger: launches the expected argv, detached and stdio-ignored", () => {
+test("spawnTelemetryTrigger: launches the expected argv, detached, hidden, and stdio-ignored", () => {
 	const fake = fakeSpawn();
 	const result = spawnTelemetryTrigger({
 		executable: "/opt/gentle-ai/gentle-ai",
@@ -88,6 +88,7 @@ test("spawnTelemetryTrigger: launches the expected argv, detached and stdio-igno
 	assert.deepEqual(call.args, ["telemetry", "trigger", "--json"]);
 	assert.equal(call.options.cwd, "/work/project");
 	assert.equal(call.options.detached, true);
+	assert.equal(call.options.windowsHide, true);
 	assert.equal(call.options.stdio, "ignore");
 });
 
@@ -212,6 +213,7 @@ test("activation: spawns the telemetry trigger exactly once for a primary sessio
 	assert.deepEqual(call.args, ["telemetry", "trigger", "--json"]);
 	assert.equal(call.options.cwd, "/work/project");
 	assert.equal(call.options.detached, true);
+	assert.equal(call.options.windowsHide, true);
 	assert.equal(call.options.stdio, "ignore");
 });