gentle-pi 3.2.1 → 3.4.0

package/tests/shell-changes.test.ts

@@ -10,6 +10,9 @@ import {
 	CHANGE_STATUS,
 	ChangesTracker,
 	WorktreeChangesTracker,
+	RootBranchLabels,
+	UNKNOWN_BRANCH,
+	foreignRootBranch,
 	parseWorktrees,
 	changesSummary,
 	emptyChanges,
@@ -19,6 +22,7 @@ import {
 	changesModel,
 	snapshotChanges,
 	type ChangedFile,
+	type GitResult,
 } from "../lib/shell-changes.ts";
 
 // The changes view shows the working tree against HEAD, new files included,
@@ -72,6 +76,16 @@ test("parsePorcelain reads NUL-separated status entries including renames and un
 	);
 });
 
+test("parsePorcelain drops embedded-repository markers, never a real file", () => {
+	// Git reports a nested .git directory (an embedded/foreign repository, the
+	// live evidence's ~/work/NaN-builders inside ~/work) as one directory-shaped
+	// "?? path/" line, never expanded into files, even with --untracked-files=all.
+	// Treating that line as a changed file creates a phantom entry for whatever
+	// ancestor repository happens to contain the nested one.
+	const raw = ["?? NaN-builders/", "?? notes.md", " M lib/a.ts"].join("\0") + "\0";
+	assert.deepEqual([...parsePorcelain(raw).entries()], [["notes.md", CHANGE_STATUS.UNTRACKED], ["lib/a.ts", CHANGE_STATUS.MODIFIED]]);
+});
+
 test("snapshotChanges merges status with counts and keeps untracked files without counts", () => {
 	const files = snapshotChanges({
 		numstat: "4\t2\tlib/a.ts\n",
@@ -265,6 +279,114 @@ test("worktree porcelain preserves unusual directory names and detached fallback
 	assert.deepEqual(parseWorktrees("worktree /a\nbranch strange\0HEAD abc\0detached\0\0"), [{ root: "/a\nbranch strange" }]);
 });
 
+// A GitRunner that cannot even ask (root removed, git missing, the runner
+// itself rejecting) must reject foreignRootBranch too -- never resolve to the
+// same undefined a genuinely detached HEAD produces. Swallowing the two into
+// one shape is exactly the bug: the caller has no way left to tell "asked and
+// there is no branch" from "could not ask at all".
+test("foreignRootBranch propagates a GitRunner failure instead of reporting detached", async () => {
+	const failing = async (): Promise<GitResult> => { throw new Error("git unavailable"); };
+	await assert.rejects(() => foreignRootBranch(failing), /git unavailable/);
+});
+
+test("foreignRootBranch still reports a genuine detached HEAD as undefined, not a failure", async () => {
+	const detached = async (args: string[]): Promise<GitResult> => (args[0] === "symbolic-ref" ? { stdout: "", code: 1 } : { stdout: "deadbeef\n", code: 0 });
+	assert.equal(await foreignRootBranch(detached), undefined);
+});
+
+// C3 (odd/tasks/usage-click-and-changes-attribution.md): a root registered by
+// the session but absent from a single `git worktree list` scan -- because it
+// belongs to a different Git clone entirely, e.g. an inner repository nested
+// inside an outer one -- must not default to "detached". It must be asked
+// directly, and "no commits yet" must read differently from a real branch.
+test("a root missing from worktree list resolves its own branch instead of defaulting to detached", async (t) => {
+	const scenarios: Array<{ name: string; symbolic: { stdout: string; code: number }; verify: { stdout: string; code: number }; expected: string | undefined }> = [
+		{ name: "a normal branch on a foreign clone", symbolic: { stdout: "feature\n", code: 0 }, verify: { stdout: "deadbeef\n", code: 0 }, expected: "feature" },
+		{ name: "an unborn branch (no commits yet)", symbolic: { stdout: "main\n", code: 0 }, verify: { stdout: "", code: 1 }, expected: "no commits yet" },
+		{ name: "a genuinely detached HEAD", symbolic: { stdout: "", code: 1 }, verify: { stdout: "deadbeef\n", code: 0 }, expected: undefined },
+	];
+	for (const scenario of scenarios) {
+		await t.test(scenario.name, async () => {
+			const calls: string[][] = [];
+			const tracker = new WorktreeChangesTracker(
+				async () => ({ stdout: "", code: 0 }), // /foreign never appears in this clone's own worktree list
+				() => async (args) => {
+					calls.push(args);
+					if (args[0] === "status") return { stdout: "?? changed.ts\0", code: 0 };
+					if (args[0] === "symbolic-ref") return scenario.symbolic;
+					if (args[0] === "rev-parse") return scenario.verify;
+					return { stdout: "", code: 0 };
+				},
+				undefined,
+				() => ["/foreign"],
+			);
+			await tracker.start();
+			assert.deepEqual(tracker.worktrees.map((tree) => [tree.root, tree.branch]), [["/foreign", scenario.expected]]);
+			assert.ok(calls.some((args) => args[0] === "symbolic-ref"), "a root absent from worktree list must be asked directly");
+		});
+	}
+});
+
+// The direct per-root ask (for a root missing from worktree list) can fail on
+// its own -- root gone, git unavailable -- independently of the change scan
+// that already found real files. That failure must label the root
+// UNKNOWN_BRANCH, distinct from "detached", and must never drop the
+// already-captured changes.
+test("a root missing from worktree list keeps its changes and reads UNKNOWN_BRANCH when the direct ask fails", async () => {
+	const tracker = new WorktreeChangesTracker(
+		async () => ({ stdout: "", code: 0 }),
+		() => async (args) => {
+			if (args[0] === "status") return { stdout: "?? changed.ts\0", code: 0 };
+			if (args[0] === "diff") return { stdout: "", code: 0 };
+			throw new Error("git unavailable"); // symbolic-ref / rev-parse: the direct branch ask
+		},
+		undefined,
+		() => ["/foreign"],
+	);
+	await tracker.start();
+	assert.deepEqual(tracker.worktrees.map((tree) => [tree.root, tree.branch]), [["/foreign", UNKNOWN_BRANCH]]);
+	assert.equal(tracker.worktrees[0]!.model.files.length, 1, "a failed branch lookup must not drop the root's real changes");
+});
+
+// A root already described by the same clone's own worktree list is trusted
+// as-is: a real "detached" marker there is already 100% accurate, so no
+// redundant per-root call is needed (and none happens).
+test("a root already described by worktree list is trusted without a redundant lookup", async () => {
+	const calls: string[][] = [];
+	const tracker = new WorktreeChangesTracker(
+		async () => ({ stdout: "worktree /known\0detached\0\0", code: 0 }),
+		() => async (args) => {
+			calls.push(args);
+			return { stdout: args[0] === "status" ? "?? changed.ts\0" : "", code: 0 };
+		},
+		undefined,
+		() => ["/known"],
+	);
+	await tracker.start();
+	assert.deepEqual(tracker.worktrees.map((tree) => [tree.root, tree.branch]), [["/known", undefined]]);
+	assert.ok(!calls.some((args) => args[0] === "symbolic-ref"), "a known worktree-list entry must not trigger a fallback call");
+});
+
+// The live evidence: an outer repo (~/work, no commits) whose ONLY change is
+// the embedded inner repository (~/work/NaN-builders) itself must never show
+// up as a phantom tree once the embedded-repo marker is filtered out of its
+// own file list -- it never had a real file to show in the first place.
+test("an outer ancestor whose only change is the embedded inner repository is never a phantom tree", async () => {
+	const tracker = new WorktreeChangesTracker(
+		async () => ({ stdout: "", code: 0 }), // neither root belongs to the other's clone
+		(root) => async (args) => {
+			if (args[0] !== "status") return { stdout: "", code: 0 };
+			// The outer root's only "change" is the nested repo directory marker;
+			// the inner root has a real file of its own.
+			return { stdout: root === "/outer" ? "?? NaN-builders/\0" : "?? jpg-png-converter.md\0", code: 0 };
+		},
+		undefined,
+		() => ["/outer", "/outer/NaN-builders"],
+	);
+	await tracker.start();
+	assert.deepEqual(tracker.worktrees.map((tree) => tree.root), ["/outer/NaN-builders"]);
+});
+
 test("registered roots remain scannable during metadata discovery failure", async () => {
 	let code = 128;
 	const tracker = new WorktreeChangesTracker(async () => ({ stdout: "worktree /repo\0\0", code }), () => async (args) => ({ stdout: args[0] === "status" ? "?? new.ts\0" : "", code: 0 }), undefined, () => ["/repo"]);
@@ -356,3 +478,58 @@ test("ChangesTracker counts the lines of untracked files, which git numstat leav
 	assert.equal(model.added, 3);
 	assert.deepEqual(counted, ["notes.md", "empty.md"]);
 });
+
+// The session-evidence tracker behind /gentle:changes knows roots, never
+// branches. The overlay decorates its trees with each root's own HEAD state,
+// resolved once per root and reported back so the view can repaint; until git
+// answers the tree shows no branch (the view's "detached" fallback), and a
+// genuinely detached HEAD stays that way.
+test("RootBranchLabels decorates session trees with each root's branch once git answers", async () => {
+	const calls = new Map<string, string[][]>();
+	const answers: Record<string, { symbolic: { stdout: string; code: number }; verify: { stdout: string; code: number } }> = {
+		"/repo": { symbolic: { stdout: "feature\n", code: 0 }, verify: { stdout: "deadbeef\n", code: 0 } },
+		"/fresh": { symbolic: { stdout: "main\n", code: 0 }, verify: { stdout: "", code: 1 } },
+		"/pinned": { symbolic: { stdout: "", code: 1 }, verify: { stdout: "deadbeef\n", code: 0 } },
+	};
+	let changed = 0;
+	const labels = new RootBranchLabels((root) => async (args) => {
+		calls.set(root, [...(calls.get(root) ?? []), args]);
+		await new Promise((resolve) => setImmediate(resolve));
+		return args[0] === "symbolic-ref" ? answers[root]!.symbolic : answers[root]!.verify;
+	}, () => changed++);
+	const trees = Object.keys(answers).map((root) => ({ root, model: changesModel([]) }));
+	const first = labels.decorate(trees);
+	assert.deepEqual(first.map((tree) => tree.branch), [undefined, undefined, undefined], "nothing is labelled before git answers");
+	await labels.settled();
+	assert.equal(changed, 3, "each resolved root asks the view to repaint once");
+	const second = labels.decorate(trees);
+	assert.deepEqual(second.map((tree) => tree.branch), ["feature", "no commits yet", undefined]);
+	labels.decorate(trees);
+	await labels.settled();
+	assert.deepEqual([...calls.values()].map((list) => list.length), [2, 2, 1], "one resolution per root, never per decorate call");
+	assert.equal(changed, 3);
+});
+
+// A root that could not even be asked (removed, git unavailable, the runner
+// itself rejecting) must read UNKNOWN_BRANCH -- never the same undefined a
+// genuine detached HEAD produces, and never silently stay unlabelled forever.
+test("RootBranchLabels labels a root UNKNOWN_BRANCH when it could not be asked, distinct from a real detached HEAD", async () => {
+	let changed = 0;
+	const labels = new RootBranchLabels((root) => async () => {
+		await new Promise((resolve) => setImmediate(resolve));
+		if (root === "/gone") throw new Error("root removed");
+		return { stdout: "", code: 1 };
+	}, () => changed++);
+	const trees = [
+		{ root: "/gone", model: changesModel([]) },
+		{ root: "/detached", model: changesModel([]) },
+	];
+	labels.decorate(trees);
+	await labels.settled();
+	assert.deepEqual(
+		labels.decorate(trees).map((tree) => tree.branch),
+		[UNKNOWN_BRANCH, undefined],
+		"a failed ask reads UNKNOWN_BRANCH; a real detached HEAD still reads undefined (the view's detached fallback)",
+	);
+	assert.equal(changed, 2, "a failed ask still resolves and asks the view to repaint, instead of hanging forever");
+});

package/tests/shell-hover.test.ts

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { HOVER_ROLE, paintHoverable } from "../lib/shell-hover.ts";
+
+const theme = {
+	fg(role: string, text: string) {
+		return `<${role}>${text}</${role}>`;
+	},
+};
+
+test("paintHoverable paints the shared hover role only while hovered", () => {
+	assert.equal(paintHoverable(theme, "refresh", true), `<${HOVER_ROLE}>refresh</${HOVER_ROLE}>`);
+	assert.equal(paintHoverable(theme, "refresh", false), "refresh");
+});
+
+test("paintHoverable falls back to an idle role when given one", () => {
+	assert.equal(paintHoverable(theme, "refresh", false, "dim"), "<dim>refresh</dim>");
+	assert.equal(paintHoverable(theme, "refresh", true, "dim"), `<${HOVER_ROLE}>refresh</${HOVER_ROLE}>`, "hover always wins over the idle role");
+});

package/tests/shell-prompt.test.ts

@@ -128,6 +128,26 @@ test("framePromptLines keeps the editor scroll indicators inside the frame", ()
 	for (const line of lines) assert.equal(visibleWidth(line), width);
 });
 
+test("framePromptLines shows an explicit escHint on the bottom rule, overriding the editor's own scroll indicator", () => {
+	const width = 40;
+	const inner = width - 2;
+	const bottom = `─── ↓ 3 more ${"─".repeat(inner - 13)}`;
+	const lines = framePromptLines(
+		["─".repeat(inner), ` x${" ".repeat(inner - 2)}`, bottom],
+		width,
+		options({ fg: (_c, t) => t, escHint: "esc again to cancel" }),
+	);
+	assert.match(stripAnsi(lines[2]), /^╰─ esc again to cancel ─+╯$/);
+});
+
+test("framePromptLines falls back to the scroll indicator when no escHint is set", () => {
+	const width = 40;
+	const inner = width - 2;
+	const bottom = `─── ↓ 3 more ${"─".repeat(inner - 13)}`;
+	const lines = framePromptLines(["─".repeat(inner), ` x${" ".repeat(inner - 2)}`, bottom], width, options({ fg: (_c, t) => t }));
+	assert.match(stripAnsi(lines[2]), /^╰─ ↓ 3 more ─+╯$/);
+});
+
 test("withPromptHint places a dim hint after the cursor on an empty editor line", () => {
 	const inner = 38;
 	const line = ` ${CURSOR}${" ".repeat(inner - 2)}`;

package/tests/shell-sidebar-fullscreen.test.ts

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Container, Spacer, TuiAltScreen, type Component } from "@earendil-works/pi-tui";
+import { createChatViewport } from "../node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/chat-viewport.js";
+import { installSidebar } from "../lib/shell-sidebar-layout.ts";
+import { sidebarHeader, sidebarPart } from "../lib/shell-sidebar.ts";
+
+// End-to-end through pi-tui's real alt-screen renderer and Pi's real chat
+// viewport: the unit fixtures elsewhere hand-build layout nodes, which is how
+// two earlier attempts at this row passed their tests and still failed live.
+const theme = { fg: (_color: string, text: string) => text, bold: (text: string) => text };
+const strip = (text: string) => text.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "").replace(/\s+$/, "");
+const lines = (rows: string[]): Component => ({ render: () => rows, invalidate() {} });
+
+async function renderViewport(columns: number, rows: number, sidebar: boolean): Promise<string[]> {
+	const terminal = {
+		start() {}, stop() {}, async drainInput() {}, write() {},
+		get columns() { return columns; }, get rows() { return rows; },
+		moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {}, setTitle() {}, setProgress() {},
+		kittyProtocolActive: false, getBufferedInput() { return ""; }, hasPendingInput() { return false; },
+	} as never;
+	const above = new Container();
+	above.addChild(new Spacer(1)); // Pi adds a spacer above the editor when no widget is shown
+	const footer = new Container();
+	const viewport = createChatViewport({
+		document: lines(Array.from({ length: 12 }, (_, i) => `transcript ${i + 1}`)),
+		pendingMessages: new Container(), status: new Container(), widgetsAbove: above,
+		editor: lines(["╭─ editor ─╮", "│ prompt   │", "╰──────────╯"]),
+		widgetsBelow: new Container(), footer, scrollbar: "auto",
+	});
+	const tui = new TuiAltScreen(terminal, false);
+	tui.setLayoutRoot(viewport.root);
+	if (sidebar) {
+		footer.addChild(sidebarPart(tui, "footer", lines(["BOTTOM BAR"]), { render: () => ["Status card"], invalidate() {} }));
+		sidebarHeader(tui, { render: (width: number) => [`HEADER ${width}`], invalidate() {} });
+		installSidebar(tui, theme);
+	} else {
+		footer.addChild(lines(["BOTTOM BAR"]));
+	}
+	tui.start();
+	tui.requestRender(true);
+	await new Promise((resolve) => setTimeout(resolve, 20));
+	tui.stop();
+	return ((tui as unknown as { previousScreen: string[] }).previousScreen ?? []).map(strip);
+}
+
+test("fullscreen with the sidebar leaves no blank row between the editor and the terminal edge", async () => {
+	const screen = await renderViewport(140, 24, true);
+	assert.equal(screen[0], "HEADER 138", "the header owns the first row");
+	assert.match(screen[screen.length - 1] ?? "", /^╰/, `the editor's bottom border sits on the last row, got ${JSON.stringify(screen.slice(-3))}`);
+	assert.ok(screen.some((row) => row.startsWith("╭─ editor")), "the editor is still painted");
+	assert.ok(screen.some((row) => row.includes("Status card")), "the rail is still painted");
+});
+
+test("fullscreen without the sidebar keeps Pi's bottom bar on the last row", async () => {
+	const screen = await renderViewport(140, 24, false);
+	assert.equal(screen[screen.length - 1], "BOTTOM BAR");
+	assert.match(screen[screen.length - 2] ?? "", /^╰/);
+});