@selesai/code 0.9.15 → 0.10.1

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

@@ -0,0 +1,431 @@
+import { describe, expect, it } from "vitest";
+import { FOOTER_FORMAT_ALIASES } from "../extensions/zentui/config";
+import {
+	collectFooterFormatReferences,
+	compileCompactFormat,
+	joinNonEmpty,
+	parseFooterFormat,
+	renderFormatSplit,
+	renderFormatTokens,
+	stripOrphanSeparators,
+} from "../extensions/zentui/footer-format";
+
+describe("parseFooterFormat", () => {
+	it("returns empty array for empty string", () => {
+		expect(parseFooterFormat("")).toEqual([]);
+	});
+
+	it("parses a single variable", () => {
+		expect(parseFooterFormat("$cwd")).toEqual([{ kind: "var", name: "cwd" }]);
+	});
+
+	it("parses model-info variables independently", () => {
+		expect(parseFooterFormat("$model $provider")).toEqual([
+			{ kind: "var", name: "model" },
+			{ kind: "text", value: " " },
+			{ kind: "var", name: "provider" },
+		]);
+	});
+
+	it("parses $package and $package_version as package-version vars", () => {
+		expect(parseFooterFormat("$package")).toEqual([{ kind: "var", name: "package" }]);
+		expect(parseFooterFormat("$package_version")).toEqual([
+			{ kind: "var", name: "package_version" },
+		]);
+	});
+
+	it("parses $git_commit, $commit, $git_tag, and $tag as git-commit vars", () => {
+		expect(parseFooterFormat("$git_commit")).toEqual([{ kind: "var", name: "git_commit" }]);
+		expect(parseFooterFormat("$commit")).toEqual([{ kind: "var", name: "commit" }]);
+		expect(parseFooterFormat("$git_tag")).toEqual([{ kind: "var", name: "git_tag" }]);
+		expect(parseFooterFormat("$tag")).toEqual([{ kind: "var", name: "tag" }]);
+	});
+
+	it("parses git-metrics vars", () => {
+		expect(parseFooterFormat("$git_metrics")).toEqual([{ kind: "var", name: "git_metrics" }]);
+		expect(parseFooterFormat("$git_added")).toEqual([{ kind: "var", name: "git_added" }]);
+		expect(parseFooterFormat("$git_deleted")).toEqual([{ kind: "var", name: "git_deleted" }]);
+	});
+
+	it("parses braced variables", () => {
+		const braced = "${" + "git_branch}";
+		expect(parseFooterFormat(braced)).toEqual([{ kind: "var", name: "git_branch" }]);
+	});
+
+	it("parses text and variables mixed", () => {
+		expect(parseFooterFormat("$cwd on $git_branch")).toEqual([
+			{ kind: "var", name: "cwd" },
+			{ kind: "text", value: " on " },
+			{ kind: "var", name: "git_branch" },
+		]);
+	});
+
+	it("parses the fill token", () => {
+		expect(parseFooterFormat("$fill")).toEqual([{ kind: "fill" }]);
+	});
+
+	it("preserves literal text exactly including multiple spaces", () => {
+		const tokens = parseFooterFormat("$cwd   on   $git_branch");
+		expect(tokens).toEqual([
+			{ kind: "var", name: "cwd" },
+			{ kind: "text", value: "   on   " },
+			{ kind: "var", name: "git_branch" },
+		]);
+	});
+
+	it("preserves leading and trailing text", () => {
+		const tokens = parseFooterFormat("prefix $cwd suffix");
+		expect(tokens).toEqual([
+			{ kind: "text", value: "prefix " },
+			{ kind: "var", name: "cwd" },
+			{ kind: "text", value: " suffix" },
+		]);
+	});
+
+	it("treats unknown variable names as var tokens", () => {
+		expect(parseFooterFormat("$nope")).toEqual([{ kind: "var", name: "nope" }]);
+	});
+
+	it("handles mixed fill, vars, and text", () => {
+		expect(parseFooterFormat("$cwd on $git_branch $fill $cost $time")).toEqual([
+			{ kind: "var", name: "cwd" },
+			{ kind: "text", value: " on " },
+			{ kind: "var", name: "git_branch" },
+			{ kind: "text", value: " " },
+			{ kind: "fill" },
+			{ kind: "text", value: " " },
+			{ kind: "var", name: "cost" },
+			{ kind: "text", value: " " },
+			{ kind: "var", name: "time" },
+		]);
+	});
+});
+
+describe("renderFormatSplit", () => {
+	const renderVar = (name: string): string => {
+		const map: Record<string, string> = {
+			cwd: "DIR",
+			session_name: "Session name",
+			git_branch: "BRANCH",
+			cost: "$0",
+			time: "12:00",
+			unknown: "",
+		};
+		return map[name] ?? "";
+	};
+
+	it("splits at the first fill token into left and right", () => {
+		const tokens = parseFooterFormat("$cwd$fill$cost $time");
+		const { left, middle, right } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("DIR");
+		expect(middle).toBe("");
+		expect(right).toBe("$0 12:00");
+	});
+
+	it("puts everything in left when there is no fill", () => {
+		const tokens = parseFooterFormat("$cwd on $git_branch");
+		const { left, middle, right } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("DIR on BRANCH");
+		expect(middle).toBe("");
+		expect(right).toBe("");
+	});
+
+	it("centers content between two fills in the middle zone", () => {
+		const tokens = parseFooterFormat("$cwd$fill$cost$fill$time");
+		const { left, middle, right } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("DIR");
+		expect(middle).toBe("$0");
+		expect(right).toBe("12:00");
+	});
+
+	it("ignores fill tokens beyond the first two", () => {
+		const tokens = parseFooterFormat("$cwd$fill$cost$fill$time$fill");
+		const { left, middle, right } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("DIR");
+		expect(middle).toBe("$0");
+		expect(right).toBe("12:00");
+	});
+
+	it("renders session-name variables in plain and braced forms", () => {
+		expect(renderFormatSplit(parseFooterFormat("$session_name"), renderVar).left).toBe(
+			"Session name",
+		);
+		const bracedSessionName = "${" + "session_name}";
+		expect(renderFormatSplit(parseFooterFormat(bracedSessionName), renderVar).left).toBe(
+			"Session name",
+		);
+	});
+
+	it("renders unknown variables as empty string", () => {
+		const tokens = parseFooterFormat("$nope");
+		const { left } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("");
+	});
+
+	it("renders literal text verbatim", () => {
+		const tokens = parseFooterFormat("hello $cwd world");
+		const { left } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("hello DIR world");
+	});
+
+	it("handles empty token list", () => {
+		const { left, middle, right } = renderFormatSplit([], renderVar);
+		expect(left).toBe("");
+		expect(middle).toBe("");
+		expect(right).toBe("");
+	});
+
+	it("handles fill at the start", () => {
+		const tokens = parseFooterFormat("$fill$cost");
+		const { left, middle, right } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("");
+		expect(middle).toBe("");
+		expect(right).toBe("$0");
+	});
+
+	it("handles fill at the end", () => {
+		const tokens = parseFooterFormat("$cwd$fill");
+		const { left, middle, right } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("DIR");
+		expect(middle).toBe("");
+		expect(right).toBe("");
+	});
+});
+
+describe("conditional groups", () => {
+	const renderVar = (name: string): string => {
+		const map: Record<string, string> = {
+			cwd: "DIR",
+			git_branch: "",
+			git_status: "[!]",
+			cost: "$0",
+			runtime: "",
+		};
+		return map[name] ?? "";
+	};
+
+	it("parses group tokens", () => {
+		expect(parseFooterFormat("($git_branch)")).toEqual([
+			{ kind: "group", tokens: [{ kind: "var", name: "git_branch" }] },
+		]);
+	});
+
+	it("drops a group when all vars are empty", () => {
+		const tokens = parseFooterFormat("($git_branch)");
+		expect(renderFormatSplit(tokens, renderVar).left).toBe("");
+	});
+
+	it("drops surrounding literals inside an empty group", () => {
+		const tokens = parseFooterFormat("($git_branch on )$cwd");
+		expect(renderFormatSplit(tokens, renderVar).left).toBe("DIR");
+	});
+
+	it("keeps a group when any var is non-empty", () => {
+		const tokens = parseFooterFormat("($git_status)");
+		expect(renderFormatSplit(tokens, renderVar).left).toBe("[!]");
+	});
+
+	it("supports nested groups", () => {
+		const tokens = parseFooterFormat("(($git_branch) via $runtime)$cwd");
+		expect(renderFormatSplit(tokens, renderVar).left).toBe("DIR");
+	});
+
+	it("still splits on fill outside groups", () => {
+		const tokens = parseFooterFormat("$cwd$fill($cost)");
+		const { left, right } = renderFormatSplit(tokens, renderVar);
+		expect(left).toBe("DIR");
+		expect(right).toBe("$0");
+	});
+
+	it("shows text-only groups", () => {
+		const tokens = parseFooterFormat("(literal)$cwd");
+		expect(renderFormatSplit(tokens, renderVar).left).toBe("literalDIR");
+	});
+
+	it("treats unmatched top-level ) as literal and keeps trailing tokens", () => {
+		const tokens = parseFooterFormat("$cwd) $cost");
+		expect(tokens).toEqual([
+			{ kind: "var", name: "cwd" },
+			{ kind: "text", value: ") " },
+			{ kind: "var", name: "cost" },
+		]);
+		expect(renderFormatSplit(tokens, renderVar).left).toBe("DIR) $0");
+	});
+
+	it("keeps nested groups working when trailing tokens follow a closed group", () => {
+		const tokens = parseFooterFormat("($git_status)$cwd");
+		expect(renderFormatSplit(tokens, renderVar).left).toBe("[!]DIR");
+	});
+	it("drops a conditional session-name group when the name is empty", () => {
+		const noSessionName = (name: string) => (name === "sep" ? " | " : "");
+		const raw = renderFormatSplit(parseFooterFormat("($sep$session_name)"), noSessionName).left;
+		expect(stripOrphanSeparators(raw)).toBe("");
+	});
+});
+
+describe("joinNonEmpty", () => {
+	it("joins only non-empty parts", () => {
+		expect(joinNonEmpty(["a", "", "b", ""], " | ")).toBe("a | b");
+		expect(joinNonEmpty(["", ""], " | ")).toBe("");
+		expect(joinNonEmpty(["only"], " | ")).toBe("only");
+	});
+});
+
+describe("compact footer format", () => {
+	it("splits top-level wrap variables and records incoming boundary kinds", () => {
+		const expected = [
+			{ kind: "tokens", tokens: [{ kind: "var", name: "cwd" }], boundary: "space" },
+			{ kind: "tokens", tokens: [{ kind: "var", name: "context" }], boundary: "space" },
+		];
+		expect(compileCompactFormat(parseFooterFormat("$cwd$wrap$context"))).toEqual(expected);
+		expect(compileCompactFormat(parseFooterFormat("$cwd$" + "{wrap}$context"))).toEqual(expected);
+		expect(
+			compileCompactFormat(parseFooterFormat("$context$wrap_sep$tokens")).map(
+				({ kind, boundary }) => ({ kind, boundary }),
+			),
+		).toEqual([
+			{ kind: "tokens", boundary: "space" },
+			{ kind: "tokens", boundary: "separator" },
+		]);
+	});
+
+	it("keeps nested boundaries empty without splitting and leaves wide rendering unchanged", () => {
+		const [nested] = compileCompactFormat(
+			parseFooterFormat("$cwd(foo $wrap $context bar $wrap_sep $tokens)"),
+		);
+		expect(nested?.kind).toBe("tokens");
+		if (nested?.kind !== "tokens") return;
+		expect(
+			renderFormatTokens(
+				nested.tokens,
+				(name) => ({ cwd: "DIR", context: "CTX", tokens: "TOK" })[name] ?? "",
+			),
+		).toBe("DIRfoo  CTX bar  TOK");
+		expect(
+			renderFormatSplit(
+				parseFooterFormat("$cwd$wrap$context$wrap_sep$tokens"),
+				(name) => ({ cwd: "DIR", context: "CTX", tokens: "TOK" })[name] ?? "",
+			).left,
+		).toBe("DIRCTXTOK");
+	});
+
+	it("ignores fill and recognizes only a standalone extensions chunk", () => {
+		const chunks = compileCompactFormat(
+			parseFooterFormat("$cwd$fill$wrap $extensions $wrap prefix $extensions$wrap($extensions)"),
+		);
+		expect(chunks.map((chunk) => chunk.kind)).toEqual(["tokens", "extensions", "tokens", "tokens"]);
+	});
+
+	it("renders conditional chunks and preserves incoming boundaries around empty content", () => {
+		const chunks = compileCompactFormat(
+			parseFooterFormat("$cwd$wrap_sep$missing$wrap(on $git_branch) $git_status$wrap_sep$context"),
+		);
+		expect(chunks.map((chunk) => chunk.boundary)).toEqual([
+			"space",
+			"separator",
+			"space",
+			"separator",
+		]);
+		const rendered = chunks.flatMap((chunk) =>
+			chunk.kind === "tokens"
+				? [
+						{
+							text: renderFormatTokens(chunk.tokens, (name) =>
+								name === "git_status" ? "[!]" : "",
+							).trim(),
+							boundary: chunk.boundary,
+						},
+					]
+				: [],
+		);
+		expect(rendered).toEqual([
+			{ text: "", boundary: "space" },
+			{ text: "", boundary: "separator" },
+			{ text: "[!]", boundary: "space" },
+			{ text: "", boundary: "separator" },
+		]);
+	});
+
+	it("collects canonical data references and excludes layout variables", () => {
+		expect(
+			collectFooterFormatReferences(
+				parseFooterFormat(
+					"$directory $branch $model $provider $wrap $wrap_sep $extensions $fill $duration",
+				),
+				FOOTER_FORMAT_ALIASES,
+			),
+		).toEqual(new Set(["cwd", "git_branch", "model", "provider", "session_duration"]));
+	});
+});
+
+describe("stripOrphanSeparators", () => {
+	it("strips leading and trailing plain pipe separators", () => {
+		expect(stripOrphanSeparators(" | tokens")).toBe("tokens");
+		expect(stripOrphanSeparators("tokens | ")).toBe("tokens");
+		expect(stripOrphanSeparators(" | tokens | ")).toBe("tokens");
+	});
+
+	it("collapses repeated plain pipe separators", () => {
+		// Two themed/plain seps in a row produce " |  | " (space on both sides of each |).
+		expect(stripOrphanSeparators("ctx |  | tokens")).toBe("ctx | tokens");
+		expect(stripOrphanSeparators(" |  | $0")).toBe("$0");
+	});
+
+	it("strips leading/trailing whitespace after empty groups drop", () => {
+		expect(stripOrphanSeparators("  DIR")).toBe("DIR");
+		expect(stripOrphanSeparators("DIR  ")).toBe("DIR");
+		expect(stripOrphanSeparators("   ")).toBe("");
+	});
+
+	it("handles ANSI-wrapped themed separators", () => {
+		const sep = "\x1b[90m | \x1b[0m";
+		expect(stripOrphanSeparators(`${sep}tokens`)).toBe("tokens");
+		expect(stripOrphanSeparators(`ctx${sep}${sep}tokens`)).toBe(`ctx${sep}tokens`);
+		expect(stripOrphanSeparators(`ctx${sep}tokens${sep}`)).toBe(`ctx${sep}tokens`);
+		expect(stripOrphanSeparators(`${sep}tokens${sep}cost`)).toBe(`tokens${sep}cost`);
+	});
+
+	it("does not destroy intentional pipes without surrounding spaces", () => {
+		expect(stripOrphanSeparators("branch|feature")).toBe("branch|feature");
+	});
+
+	it("tidies right-side groups with empty middle metrics", () => {
+		const renderVar = (name: string): string => {
+			const map: Record<string, string> = {
+				context: "",
+				tokens: "",
+				cost: "$0",
+				sep: " | ",
+			};
+			return map[name] ?? "";
+		};
+		const tokens = parseFooterFormat("($context)($sep$tokens)($sep$cost)");
+
+		// Empty content vars drop their groups even when $sep is present.
+		const raw = renderFormatSplit(tokens, renderVar).left;
+		expect(raw).toBe(" | $0");
+		expect(stripOrphanSeparators(raw)).toBe("$0");
+	});
+
+	it("drops groups whose only non-empty var is $sep", () => {
+		const renderVar = (name: string): string => (name === "sep" ? " | " : "");
+		const tokens = parseFooterFormat("($sep$tokens)cwd");
+		expect(renderFormatSplit(tokens, renderVar).left).toBe("cwd");
+	});
+
+	it("preserves themed separators between non-empty parts", () => {
+		const sep = "\x1b[90m | \x1b[0m";
+		const renderVar = (name: string): string => {
+			const map: Record<string, string> = {
+				context: "72%",
+				tokens: "↑1",
+				cost: "$0",
+				sep,
+			};
+			return map[name] ?? "";
+		};
+		const tokens = parseFooterFormat("($context)($sep$tokens)($sep$cost)");
+		const raw = renderFormatSplit(tokens, renderVar).left;
+		expect(stripOrphanSeparators(raw)).toBe(`72%${sep}↑1${sep}$0`);
+	});
+});

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

@@ -0,0 +1,113 @@
+import { stripVTControlCharacters } from "node:util";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it } from "vitest";
+import {
+	compactChunkBudget,
+	fullFooterFitsAligned,
+	packCompactChunks,
+	reflowFullFooter,
+} from "../extensions/zentui/footer-layout";
+
+const chunk = (text: string, boundary: "space" | "separator" = "space") => ({
+	text,
+	boundary,
+});
+
+describe("responsive footer layout", () => {
+	it("models centered-middle placement and its floor bias", () => {
+		expect(fullFooterFitsAligned({ left: "LLLLL", middle: "MMMM", right: "" }, 10)).toBe(false);
+		expect(fullFooterFitsAligned({ left: "LLLLL", middle: "MMMM", right: "" }, 11)).toBe(true);
+		expect(fullFooterFitsAligned({ left: "", middle: "MMMM", right: "RRRRR" }, 10)).toBe(true);
+		expect(fullFooterFitsAligned({ left: "LLLL", middle: "MMM", right: "RRRR" }, 13)).toBe(true);
+		expect(fullFooterFitsAligned({ left: "LLLL", middle: "MMM", right: "RRRR" }, 12)).toBe(false);
+	});
+
+	it("measures ANSI and Nerd Font content by visible terminal cells", () => {
+		const zones = { left: "\u001b[31mLL\u001b[0m", middle: "\ue0a0", right: "RR" };
+		expect(fullFooterFitsAligned(zones, 7)).toBe(true);
+		expect(fullFooterFitsAligned(zones, 6)).toBe(false);
+	});
+
+	it("prefers left / middle+right and falls back to left+middle / right", () => {
+		expect(reflowFullFooter({ left: "LLLL", middle: "MM", right: "RR" }, 5)).toEqual([
+			"LLLL",
+			"MM RR",
+		]);
+		expect(reflowFullFooter({ left: "L", middle: "MMMM", right: "RRRR" }, 6)).toEqual([
+			"L MMMM",
+			"RRRR",
+		]);
+		expect(reflowFullFooter({ left: "LLLLLL", middle: "MMMM", right: "RRRR" }, 6)).toBeUndefined();
+	});
+
+	it("collapses empty reflow zones without blank rows or stray spaces", () => {
+		expect(reflowFullFooter({ left: "L", middle: "", right: "R" }, 2)).toEqual(["L", "R"]);
+		expect(reflowFullFooter({ left: "", middle: "M", right: "R" }, 3)).toEqual(["M R"]);
+		expect(reflowFullFooter({ left: "L", middle: "M", right: "" }, 3)).toEqual(["L", "M"]);
+	});
+
+	it("uses the exact half-row compact budget", () => {
+		expect(compactChunkBudget(47)).toBe(23);
+		expect(compactChunkBudget(19)).toBe(9);
+		expect(compactChunkBudget(17)).toBe(8);
+		expect(compactChunkBudget(8)).toBe(8);
+		expect(compactChunkBudget(5)).toBe(8);
+	});
+
+	it("packs chunks with boundary-aware same-row joins and no divider at breaks", () => {
+		expect(packCompactChunks([chunk("one"), chunk("two")], 7, 2, " | ")).toEqual(["one two"]);
+		expect(packCompactChunks([chunk("one"), chunk("two", "separator")], 9, 2, " | ")).toEqual([
+			"one | two",
+		]);
+		expect(packCompactChunks([chunk("one"), chunk("two", "separator")], 8, 2, " | ")).toEqual([
+			"one",
+			"two",
+		]);
+		expect(
+			packCompactChunks([chunk("one"), chunk(""), chunk("  "), chunk("two")], 7, 2, " | "),
+		).toEqual(["one two"]);
+	});
+
+	it("retains the next surviving chunk's incoming boundary", () => {
+		expect(
+			packCompactChunks([chunk("A"), chunk("", "separator"), chunk("B", "space")], 5, 2, " | "),
+		).toEqual(["A B"]);
+		expect(
+			packCompactChunks([chunk("A"), chunk("", "space"), chunk("B", "separator")], 5, 2, " | "),
+		).toEqual(["A | B"]);
+	});
+
+	it("supports every finite line limit and unlimited rows", () => {
+		const chunks = [chunk("one"), chunk("two"), chunk("three")];
+		expect(packCompactChunks(chunks, 5, 1, " | ")).toEqual(["one…"]);
+		expect(packCompactChunks(chunks, 7, 2, " | ")).toEqual(["one two", "three"]);
+		expect(packCompactChunks(chunks, 5, 3, " | ")).toEqual(["one", "two", "three"]);
+		expect(packCompactChunks(chunks, 5, "unlimited", " | ")).toEqual(["one", "two", "three"]);
+	});
+
+	it("marks finite-cap omissions with exactly one ellipsis", () => {
+		expect(
+			packCompactChunks([chunk("12345"), chunk("later")], 5, 1, " | ").map(
+				stripVTControlCharacters,
+			),
+		).toEqual(["1234…"]);
+		expect(
+			packCompactChunks([chunk("123456789"), chunk("later")], 5, 1, " | ").map(
+				stripVTControlCharacters,
+			),
+		).toEqual(["1234…"]);
+	});
+
+	it("keeps every ANSI and wide-glyph row within width, even below the compact budget", () => {
+		const rows = packCompactChunks(
+			[chunk("\u001b[31mabcdef\u001b[0m"), chunk("界界界"), chunk("\ue0a0")],
+			5,
+			3,
+			" | ",
+		);
+		expect(rows.every((row) => visibleWidth(row) <= 5)).toBe(true);
+		expect(
+			packCompactChunks([chunk("abcdefgh")], 5, 1, " | ").every((row) => visibleWidth(row) <= 5),
+		).toBe(true);
+	});
+});

package/dist/extensions/pi-zentui/test/footer-repository-path.test.ts

@@ -0,0 +1,123 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { describe, expect, it, vi } from "vitest";
+import { defaultConfig } from "../extensions/zentui/config";
+import { installFooter } from "../extensions/zentui/footer";
+import { emptyGitStatus } from "../extensions/zentui/git";
+import { createInitialState } from "../extensions/zentui/state";
+
+type FooterFactory = (
+	tui: { requestRender(): void },
+	theme: Theme,
+	data: {
+		onBranchChange(callback: () => void): () => void;
+		getExtensionStatuses(): Map<string, string>;
+	},
+) => { render(width: number): string[] };
+
+function theme(): Theme {
+	return {
+		fg: (_color: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		underline: (text: string) => text,
+		strikethrough: (text: string) => text,
+		getThinkingBorderColor: () => (text: string) => text,
+	} as unknown as Theme;
+}
+
+describe("Footer repository path rendering", () => {
+	it("uses the same repository cwd in built-in, custom, and final responsive fallback output", () => {
+		let footerFactory: FooterFactory | undefined;
+		const cwd = "/repo/extensions/zentui";
+		const context = {
+			cwd,
+			model: { contextWindow: 100_000 },
+			getContextUsage: () => ({ percent: 10, tokens: 10_000, contextWindow: 100_000 }),
+			sessionManager: { getSessionName: () => undefined },
+			ui: {
+				setFooter(factory: FooterFactory | undefined) {
+					footerFactory = factory;
+				},
+			},
+		};
+		const config = structuredClone(defaultConfig);
+		config.icons.cwd = "";
+		config.components.footer.styles.starship.pathDisplay = {
+			mode: "repository",
+			depth: 0,
+		};
+		const render = (width: number) => {
+			installFooter(context as never, createInitialState(emptyGitStatus()), () => config, {
+				setRequestRender() {},
+				scheduleProjectRefresh() {},
+				getRepositoryRoot: () => "/repo",
+			});
+			const footer = footerFactory?.({ requestRender() {} }, theme(), {
+				onBranchChange: () => () => {},
+				getExtensionStatuses: () => new Map(),
+			});
+			return footer?.render(width).join("\n") ?? "";
+		};
+
+		const starship = config.components.footer.styles.starship;
+		starship.responsive = false;
+		starship.format = "";
+		const builtIn = render(160);
+		expect(builtIn).toMatch(/(?:^|\s)extensions\/zentui(?:\s|$)/);
+		expect(builtIn).not.toContain("/repo/extensions/zentui");
+
+		starship.format = "$cwd";
+		const custom = render(160);
+		expect(custom.trim()).toBe("extensions/zentui");
+		expect(custom).not.toContain("/repo/extensions/zentui");
+
+		starship.responsive = true;
+		starship.format = "X".repeat(100);
+		starship.compactFormat = "$cwd";
+		const compact = render(50);
+		expect(compact.trim()).toBe("extensions/zentui");
+		expect(compact).not.toContain("/repo/extensions/zentui");
+	});
+
+	it("only asks for a repository root in repository mode", () => {
+		let footerFactory: FooterFactory | undefined;
+		const config = structuredClone(defaultConfig);
+		config.icons.cwd = "";
+		const getRepositoryRoot = vi.fn(() => "/repo");
+		installFooter(
+			{
+				cwd: "/repo/extensions/zentui",
+				model: { contextWindow: 100_000 },
+				getContextUsage: () => ({ percent: 10, tokens: 10_000, contextWindow: 100_000 }),
+				sessionManager: { getSessionName: () => undefined },
+				ui: {
+					setFooter(factory: FooterFactory | undefined) {
+						footerFactory = factory;
+					},
+				},
+			} as never,
+			createInitialState(emptyGitStatus()),
+			() => config,
+			{
+				setRequestRender() {},
+				scheduleProjectRefresh() {},
+				getRepositoryRoot,
+			},
+		);
+		const footer = footerFactory?.({ requestRender() {} }, theme(), {
+			onBranchChange: () => () => {},
+			getExtensionStatuses: () => new Map(),
+		});
+
+		config.components.footer.styles.starship.pathDisplay.mode = "basename";
+		footer?.render(160);
+		config.components.footer.styles.starship.pathDisplay.mode = "full";
+		footer?.render(160);
+		expect(getRepositoryRoot).not.toHaveBeenCalled();
+
+		config.components.footer.styles.starship.pathDisplay.mode = "repository";
+		footer?.render(160);
+		expect(getRepositoryRoot).toHaveBeenCalledTimes(1);
+		expect(getRepositoryRoot).toHaveBeenCalledWith("/repo/extensions/zentui");
+	});
+});