@underactive/pi-topping-statusline 0.1.0

package/src/tests/feeds.test.ts

@@ -0,0 +1,368 @@
+/**
+ * Contracts for the feeds segment, which surfaces values other extensions
+ * publish as custom session entries. The default subscription targets
+ * pi-prompt-cache's savings feed, whose author specified the currency rules.
+ *
+ * Ordering matters here: a publisher emits at turn end or after compaction,
+ * both of which require a completed model call, so a live entry is always
+ * written after the consumer's session_start. Fabricating a timestamp before
+ * attaching would exercise an ordering the real system cannot produce, and the
+ * stale-run guard would discard it.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import { SegmentContextBuilder } from "../context.ts";
+import { SEGMENTS } from "../segments.ts";
+import { DEFAULT_FEEDS, DEFAULT_SEGMENTS, resolveEffectiveSettings, sanitizeFeeds } from "../settings.ts";
+import { theme } from "../theme.ts";
+import type { SegmentContext, StatusLineFeed } from "../types.ts";
+
+const SAVINGS = "pi-prompt-cache/savings";
+const OPTIONS = resolveEffectiveSettings({}).segmentOptions;
+const INCLUDE = { git: false, pr: false, piStats: false, tokenRate: false, feeds: [SAVINGS] };
+/** Outside any repo, so the builder's git probes stay inert. */
+const CWD = "/tmp/pi-topping-statusline-tests";
+
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "");
+
+// Partial stand-ins: the builder only reaches the members defined here.
+const fakePi = { exec: async () => undefined, getThinkingLevel: () => "off" } as unknown as ExtensionAPI;
+const fakeCtx = (entries: SessionEntry[], onScan?: () => void): ExtensionContext =>
+	({
+		cwd: CWD,
+		sessionManager: {
+			getEntries: () => {
+				onScan?.();
+				return entries;
+			},
+			getSessionName: () => undefined,
+		},
+		getContextUsage: () => undefined,
+		model: undefined,
+	}) as unknown as ExtensionContext;
+
+const feedEntry = (data: unknown, customType = SAVINGS, timestamp = new Date().toISOString()): SessionEntry =>
+	({ type: "custom", customType, id: "e", parentId: null, timestamp, data }) as SessionEntry;
+
+/** Attach first, let the clock advance, then emit — a publisher's real ordering. */
+async function contextAfterEmitting(
+	makeEntries: () => SessionEntry[],
+	include = INCLUDE,
+): Promise<SegmentContext> {
+	const entries: SessionEntry[] = [];
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(entries));
+	await sleep(3);
+	entries.push(...makeEntries());
+	return builder.build(80, OPTIONS, include, undefined);
+}
+
+const BASE = await contextAfterEmitting(() => []);
+/** Render the segment against explicit feed config and payloads. */
+const renderFeeds = (feeds: StatusLineFeed[], feedData: Record<string, unknown> | undefined) =>
+	SEGMENTS.feeds.render({ ...BASE, options: { ...BASE.options, feeds }, feedData });
+const savingsFeed = (format: StatusLineFeed["format"] = "currency", prefix = "CS"): StatusLineFeed => ({
+	customType: SAVINGS,
+	field: "savedUsd",
+	prefix,
+	format,
+});
+const renderSaved = (value: unknown, format: StatusLineFeed["format"] = "currency") =>
+	renderFeeds([savingsFeed(format)], { [SAVINGS]: { savedUsd: value } });
+
+// ── reading the feed ───────────────────────────────────────────────────────
+
+test("hidden when no publisher has emitted", async () => {
+	const ctx = await contextAfterEmitting(() => []);
+	assert.deepEqual(ctx.feedData, {});
+	assert.equal(SEGMENTS.feeds.render(ctx).visible, false);
+});
+
+test("a later custom_message sharing the customType cannot shadow a real entry", async () => {
+	// CustomMessageEntry carries customType too, but keeps its payload under
+	// details. Matching on customType alone would hit this newer entry first,
+	// find nothing usable, and suppress the real value behind it.
+	const decoy = {
+		type: "custom_message",
+		customType: SAVINGS,
+		id: "m",
+		parentId: null,
+		timestamp: new Date().toISOString(),
+		content: "x",
+		display: false,
+		details: { savedUsd: 99 },
+	} as SessionEntry;
+	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 4.2 }), decoy]);
+	assert.deepEqual(ctx.feedData, { [SAVINGS]: { savedUsd: 4.2 } });
+});
+
+test("unsubscribed customTypes are ignored", async () => {
+	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 9 }, "other-ext/thing")]);
+	assert.deepEqual(ctx.feedData, {});
+});
+
+test("the newest matching entry wins", async () => {
+	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 0.5 }), feedEntry({ savedUsd: 1.2345 })]);
+	assert.deepEqual(ctx.feedData, { [SAVINGS]: { savedUsd: 1.2345 } });
+});
+
+test("several feeds are collected in one pass and render together", async () => {
+	const include = { ...INCLUDE, feeds: [SAVINGS, "my-ext/tokens"] };
+	const ctx = await contextAfterEmitting(
+		() => [feedEntry({ savedUsd: 1.5 }), feedEntry({ count: 42 }, "my-ext/tokens")],
+		include,
+	);
+	const feeds: StatusLineFeed[] = [
+		savingsFeed(),
+		{ customType: "my-ext/tokens", field: "count", prefix: "TOK ", format: "number" },
+	];
+	assert.equal(stripAnsi(renderFeeds(feeds, ctx.feedData).content), "CS$1.50 TOK 42");
+});
+
+test("a subscribed feed with no publisher simply contributes nothing", async () => {
+	const include = { ...INCLUDE, feeds: [SAVINGS, "absent/feed"] };
+	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 2 })], include);
+	const feeds: StatusLineFeed[] = [
+		savingsFeed(),
+		{ customType: "absent/feed", field: "x", prefix: "AB", format: "number" },
+	];
+	assert.equal(stripAnsi(renderFeeds(feeds, ctx.feedData).content), "CS$2.00");
+});
+
+test("missing fields and malformed payloads do not surface", () => {
+	assert.equal(renderSaved("1.23").visible, false, "a string is not a currency value");
+	assert.equal(renderSaved(Number.NaN).visible, false);
+	assert.equal(renderSaved(undefined).visible, false);
+	assert.equal(renderFeeds([savingsFeed()], { [SAVINGS]: { other: 1 } }).visible, false);
+	assert.equal(renderFeeds([savingsFeed()], { [SAVINGS]: 5 }).visible, false, "payload must be an object");
+});
+
+// ── the per-run reset ──────────────────────────────────────────────────────
+
+test("entries predating this run are stale and render nothing", async () => {
+	const priorRun = new Date(Date.now() - 60_000).toISOString();
+	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 7.77 }, SAVINGS, priorRun)]);
+	assert.deepEqual(ctx.feedData, {}, "a prior run's figure must not surface");
+});
+
+test("the first emission of the new run supersedes a stale one", async () => {
+	const priorRun = new Date(Date.now() - 60_000).toISOString();
+	const ctx = await contextAfterEmitting(() => [
+		feedEntry({ savedUsd: 7.77 }, SAVINGS, priorRun),
+		feedEntry({ savedUsd: 0.42 }),
+	]);
+	assert.deepEqual(ctx.feedData, { [SAVINGS]: { savedUsd: 0.42 } });
+});
+
+test("session replacement inside the TTL window drops the cached payload", async () => {
+	const entries: SessionEntry[] = [];
+	const builder = new SegmentContextBuilder(fakePi);
+
+	builder.attach(fakeCtx(entries));
+	await sleep(3);
+	entries.push(feedEntry({ savedUsd: 4.2 }));
+	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, { [SAVINGS]: { savedUsd: 4.2 } });
+
+	// /new, /resume and /fork replace the session in-process; publishers reset,
+	// so the entries above now belong to a previous run.
+	await sleep(3);
+	builder.attach(fakeCtx(entries));
+	assert.deepEqual(
+		builder.build(80, OPTIONS, INCLUDE, undefined).feedData,
+		{},
+		"must rescan on attach rather than serve the prior session's payload",
+	);
+});
+
+test("no stale frame is observable across the whole TTL window", async () => {
+	const entries: SessionEntry[] = [];
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(entries));
+	await sleep(3);
+	entries.push(feedEntry({ savedUsd: 9.99 }));
+	builder.build(80, OPTIONS, INCLUDE, undefined);
+
+	await sleep(3);
+	builder.attach(fakeCtx(entries));
+	for (let frame = 0; frame < 10; frame++) {
+		assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, {}, `frame ${frame} leaked`);
+		await sleep(30);
+	}
+});
+
+// ── scan cost ──────────────────────────────────────────────────────────────
+
+test("no subscriptions means the session is never read", () => {
+	let scans = 0;
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx([feedEntry({ savedUsd: 1 })], () => scans++));
+	const ctx = builder.build(80, OPTIONS, { ...INCLUDE, feeds: [] }, undefined);
+	assert.equal(scans, 0);
+	assert.equal(ctx.feedData, undefined);
+});
+
+test("renders share one scan per TTL, and attach forces a fresh one", async () => {
+	let scans = 0;
+	const entries: SessionEntry[] = [];
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(entries, () => scans++));
+	await sleep(3);
+	entries.push(feedEntry({ savedUsd: 1.5 }));
+
+	for (let i = 0; i < 50; i++) builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(scans, 1, `expected 1 scan across 50 renders, got ${scans}`);
+
+	builder.attach(fakeCtx(entries, () => scans++));
+	builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(scans, 2, "attach must expire the cache rather than wait out the TTL");
+});
+
+test("changing the subscription list rescans without waiting out the TTL", async () => {
+	let scans = 0;
+	const entries: SessionEntry[] = [];
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(entries, () => scans++));
+	await sleep(3);
+	entries.push(feedEntry({ savedUsd: 1 }), feedEntry({ count: 7 }, "my-ext/tokens"));
+
+	builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(scans, 1);
+	// Adding a feed in the settings menu must take effect on the next frame.
+	const ctx = builder.build(80, OPTIONS, { ...INCLUDE, feeds: [SAVINGS, "my-ext/tokens"] }, undefined);
+	assert.equal(scans, 2);
+	assert.deepEqual(ctx.feedData, { [SAVINGS]: { savedUsd: 1 }, "my-ext/tokens": { count: 7 } });
+});
+
+test("a fresh emission appears once the TTL lapses", async () => {
+	const entries: SessionEntry[] = [];
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(entries));
+	builder.build(80, OPTIONS, INCLUDE, undefined);
+
+	await sleep(3);
+	entries.push(feedEntry({ savedUsd: 0.01 }));
+	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, {}, "still inside the TTL");
+	await sleep(2_100);
+	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, { [SAVINGS]: { savedUsd: 0.01 } });
+});
+
+// ── formats ────────────────────────────────────────────────────────────────
+
+test("currency hides sub-cent and negative values, matching the publisher's own cutoff", () => {
+	// A cold 100K-token prefix bills cacheWrite at 1.25x against a 1x baseline,
+	// so the first turns really do publish a negative figure.
+	for (const value of [-12.5, -0.03, -0.025, -0.005, -0.0001, 0, 0.002, 0.0049]) {
+		assert.equal(renderSaved(value).visible, false, `${value} must be hidden`);
+	}
+	for (const value of [0.005, 0.0164, 1.235]) {
+		assert.equal(renderSaved(value).visible, true, `${value} must show`);
+	}
+});
+
+test("no $0.00 artifact is reachable near the crossing", () => {
+	for (let value = -0.05; value <= 0.05; value += 0.0001) {
+		assert.ok(!stripAnsi(renderSaved(value).content).includes("$0.00"), `rendered $0.00 at ${value}`);
+	}
+});
+
+test("currency: two decimals below $100, whole dollars above", () => {
+	assert.equal(stripAnsi(renderSaved(0.0164).content), "CS$0.02");
+	assert.equal(stripAnsi(renderSaved(1.235).content), "CS$1.24");
+	assert.equal(stripAnsi(renderSaved(99.994).content), "CS$99.99");
+	assert.equal(stripAnsi(renderSaved(100).content), "CS$100");
+	assert.equal(stripAnsi(renderSaved(1234.56).content), "CS$1235");
+});
+
+test("number prints plainly, keeping at most two decimals and no floor", () => {
+	assert.equal(stripAnsi(renderSaved(87, "number").content), "CS87");
+	assert.equal(stripAnsi(renderSaved(1.2345, "number").content), "CS1.23");
+	assert.equal(stripAnsi(renderSaved(1.5, "number").content), "CS1.5");
+	assert.equal(stripAnsi(renderSaved(-3, "number").content), "CS-3");
+	assert.equal(stripAnsi(renderSaved(0, "number").content), "CS0", "number has no currency floor");
+});
+
+test("text prints any value as-is, sanitized", () => {
+	assert.equal(stripAnsi(renderSaved("ready", "text").content), "CSready");
+	assert.equal(stripAnsi(renderSaved(42, "text").content), "CS42");
+	assert.equal(renderSaved("", "text").visible, false);
+	assert.equal(stripAnsi(renderSaved("a\x1b[31mb", "text").content), "CSab", "escapes are stripped");
+});
+
+test("a prefix keeps deliberate spacing but never raw escapes", () => {
+	const withSpace: StatusLineFeed = { customType: SAVINGS, field: "n", prefix: "TOK ", format: "number" };
+	assert.equal(stripAnsi(renderFeeds([withSpace], { [SAVINGS]: { n: 42 } }).content), "TOK 42");
+	const prefixed = (prefix: string) =>
+		stripAnsi(renderFeeds([{ customType: SAVINGS, field: "n", prefix, format: "number" }], { [SAVINGS]: { n: 1 } }).content);
+	assert.equal(prefixed("a\x1b[31mb"), "ab1", "colour escapes are removed, not rendered");
+	assert.equal(prefixed("a\x07b"), "a b1", "control characters degrade to a space");
+	assert.equal(prefixed("a\tb"), "a b1");
+});
+
+test("the prefix is literal, so the currency symbol can live in either place", () => {
+	assert.equal(stripAnsi(renderFeeds([savingsFeed("currency", "CS")], { [SAVINGS]: { savedUsd: 1.44 } }).content), "CS$1.44");
+	assert.equal(stripAnsi(renderFeeds([savingsFeed("number", "CS$")], { [SAVINGS]: { savedUsd: 1.44 } }).content), "CS$1.44");
+	assert.equal(stripAnsi(renderFeeds([savingsFeed("currency", "")], { [SAVINGS]: { savedUsd: 1.44 } }).content), "$1.44");
+});
+
+// ── settings ───────────────────────────────────────────────────────────────
+
+test("defaults: segment off, seeded with the pi-prompt-cache subscription", () => {
+	assert.equal(DEFAULT_SEGMENTS.feeds, false);
+	assert.ok(!resolveEffectiveSettings({}).bottomRightSegments.includes("feeds"));
+	assert.deepEqual(resolveEffectiveSettings({}).segmentOptions.feeds, [
+		{ customType: SAVINGS, field: "savedUsd", prefix: "CS", format: "currency" },
+	]);
+	assert.deepEqual(resolveEffectiveSettings({ segments: { feeds: true } }).bottomRightSegments, [
+		"feeds",
+		"pi_stats",
+		"context_graph",
+	]);
+});
+
+test("feeds lead the bottom-right group", () => {
+	assert.deepEqual(
+		resolveEffectiveSettings({ segments: { feeds: true, tokenRate: true } }).bottomRightSegments,
+		["feeds", "token_rate", "pi_stats", "context_graph"],
+	);
+});
+
+test("the bottom-left group runs scroll hint, feeds, then the rate", () => {
+	assert.equal(DEFAULT_SEGMENTS.feedsBottomLeft, false);
+	assert.deepEqual(resolveEffectiveSettings({}).bottomLeftSegments, ["scroll_hint"]);
+	assert.deepEqual(
+		resolveEffectiveSettings({ segments: { feedsBottomLeft: true, tokenRateBottomLeft: true } })
+			.bottomLeftSegments,
+		["scroll_hint", "feeds", "token_rate"],
+	);
+});
+
+test("sanitizeFeeds drops unusable rows and normalizes the rest", () => {
+	assert.deepEqual(
+		sanitizeFeeds([
+			{ customType: " a/b ", field: " f ", prefix: "P", format: "number" },
+			{ customType: "", field: "f", prefix: "", format: "number" },
+			{ customType: "c/d", field: "", prefix: "", format: "number" },
+			{ customType: "e/f", field: "g", prefix: "", format: "bogus" },
+			"nonsense",
+			null,
+		]),
+		[
+			{ customType: "a/b", field: "f", prefix: "P", format: "number" },
+			{ customType: "e/f", field: "g", prefix: "", format: "text" },
+		],
+	);
+	assert.deepEqual(sanitizeFeeds(undefined), []);
+});
+
+test("an explicitly empty feed list is honoured rather than reseeded", () => {
+	assert.deepEqual(resolveEffectiveSettings({ feeds: [] }).segmentOptions.feeds, []);
+});
+
+test("the default subscription matches what pi-prompt-cache publishes", () => {
+	assert.equal(DEFAULT_FEEDS[0]?.customType, SAVINGS);
+	assert.equal(DEFAULT_FEEDS[0]?.field, "savedUsd");
+	assert.equal(DEFAULT_FEEDS[0]?.format, "currency");
+	void theme;
+});

package/src/tests/menu.test.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { MenuComponent } from "../menu.ts";
+import type { MenuSection } from "../menu.ts";
+
+const theme = { fg: (_c: string, s: string) => s, bold: (s: string) => s } as unknown as Theme;
+const plain = (lines: string[]) => lines.map(l => l.replace(/\x1b\[[0-9;]*m/g, ""));
+
+function makeSections(feeds: { customType: string; prefix: string }[]): MenuSection[] {
+	const items: any[] = [];
+	feeds.forEach((f, i) => {
+		items.push({ id: `feed.${i}.customType`, label: `${i + 1}. type`, value: f.customType, text: true, placeholder: "ext/type" });
+		items.push({ id: `feed.${i}.prefix`, label: `${i + 1}. prefix`, value: f.prefix, text: true, placeholder: "(none)" });
+		items.push({ id: `feed.${i}.remove`, label: `${i + 1}. remove`, value: false, action: true });
+	});
+	items.push({ id: "feed.add", label: "+ add feed", value: false, action: true });
+	return [{ title: "Feeds", items }];
+}
+
+function drive() {
+	let result: any;
+	const feeds = [{ customType: "pi-prompt-cache/savings", prefix: "CS" }];
+	const menu = new MenuComponent(
+		{
+			title: "T",
+			sections: makeSections(feeds),
+			onAction: (id, values) => {
+				const list: { customType: string; prefix: string }[] = [];
+				for (let i = 0; values[`feed.${i}.customType`] !== undefined; i++) {
+					list.push({ customType: String(values[`feed.${i}.customType`]), prefix: String(values[`feed.${i}.prefix`]) });
+				}
+				if (id === "feed.add") list.push({ customType: "", prefix: "" });
+				else {
+					const m = /^feed\.(\d+)\.remove$/.exec(id);
+					if (!m) return undefined;
+					list.splice(Number(m[1]), 1);
+				}
+				return makeSections(list);
+			},
+		},
+		theme,
+		r => { result = r; },
+	);
+	return { menu, get result() { return result; } };
+}
+
+const type = (menu: any, s: string) => { for (const ch of s) menu.handleInput(ch); };
+
+test("typing into a text row edits only on commit", () => {
+	const { menu } = drive();
+	menu.handleInput("\r");                    // Enter on row 0 -> begin editing
+	type(menu, "-x");
+	assert.match(plain(menu.render(60)).join("\n"), /pi-prompt-cache\/savings-x/, "buffer shown live");
+	menu.handleInput("\x7f");                  // backspace
+	menu.handleInput("\r");                    // commit
+	menu.handleInput("\x1b");                  // escape closes the menu (cancel)
+	assert.equal((menu as any).values["feed.0.customType"], "pi-prompt-cache/savings-");
+});
+
+test("escape during editing discards the buffer, not the menu", () => {
+	const { menu, } = drive();
+	menu.handleInput("\r");
+	type(menu, "ZZZ");
+	menu.handleInput("\x1b");                  // cancel the edit
+	assert.equal((menu as any).values["feed.0.customType"], "pi-prompt-cache/savings");
+	assert.equal((menu as any).editing, undefined);
+	assert.equal(drive().result, undefined);
+});
+
+test("escape sequences never enter the buffer", () => {
+	const { menu } = drive();
+	menu.handleInput("\r");
+	menu.handleInput("\x1b[A");                // an arrow key, mid-edit
+	menu.handleInput("\r");
+	assert.equal((menu as any).values["feed.0.customType"], "pi-prompt-cache/savings");
+});
+
+test("add feed appends a blank row; remove drops the right one", () => {
+	const { menu } = drive();
+	const rowsBefore = (menu as any).flat.length;
+	// cursor to "+ add feed" (last row)
+	for (let i = 0; i < rowsBefore - 1; i++) menu.handleInput("\x1b[B");
+	menu.handleInput("\r");
+	assert.equal((menu as any).flat.length, rowsBefore + 3, "one feed = 3 rows");
+	assert.equal((menu as any).values["feed.1.customType"], "");
+
+	// remove feed 1 -> back to the original row count
+	(menu as any).cursor = 5;                  // "2. remove"
+	menu.handleInput("\r");
+	assert.equal((menu as any).flat.length, rowsBefore);
+	assert.equal((menu as any).values["feed.1.customType"], undefined, "removed values do not linger");
+	assert.equal((menu as any).values["feed.0.customType"], "pi-prompt-cache/savings", "survivor kept");
+});
+
+test("cursor stays in range after a removal at the end", () => {
+	const { menu } = drive();
+	(menu as any).cursor = 2;                  // "1. remove"
+	menu.handleInput("\r");
+	assert.ok((menu as any).cursor < (menu as any).flat.length);
+	assert.doesNotThrow(() => menu.render(60));
+});
+
+test("placeholder shows for empty text rows", () => {
+	const { menu } = drive();
+	for (let i = 0; i < (menu as any).flat.length - 1; i++) menu.handleInput("\x1b[B");
+	menu.handleInput("\r");                    // add feed
+	assert.match(plain(menu.render(60)).join("\n"), /ext\/type/, "placeholder visible");
+});

package/src/tests/rainbow.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Rainbow border: perimeter walk math, per-glyph colouring, the gap
+ * geometry buildStatusLine hands the border callback, and the setting
+ * default/plumbing.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { SegmentContextBuilder } from "../context.ts";
+import { buildStatusLine } from "../layout.ts";
+import { perimeterLength, perimeterPosition, RainbowBorder } from "../rainbow.ts";
+import { resolveEffectiveSettings } from "../settings.ts";
+import { theme } from "../theme.ts";
+
+const fakePi = { exec: async () => undefined, getThinkingLevel: () => "off" } as unknown as ExtensionAPI;
+const fakeCtx = {
+	cwd: "/tmp/pi-topping-statusline-tests",
+	sessionManager: { getEntries: () => [], getSessionName: () => undefined },
+	getContextUsage: () => undefined,
+	model: undefined,
+} as unknown as ExtensionContext;
+
+const builder = new SegmentContextBuilder(fakePi);
+builder.attach(fakeCtx);
+const BASE = builder.build(
+	80,
+	resolveEffectiveSettings({}).segmentOptions,
+	{ git: false, pr: false, piStats: false, tokenRate: false, feeds: [] },
+	undefined,
+);
+
+/** Border cells in clockwise walk order, starting at the top-left corner. */
+function walkPositions(width: number, bottomIdx: number): number[] {
+	const positions: number[] = [];
+	for (let col = 0; col < width; col++) positions.push(perimeterPosition(0, col, width, bottomIdx));
+	for (let row = 1; row < bottomIdx; row++) positions.push(perimeterPosition(row, width - 1, width, bottomIdx));
+	for (let col = width - 1; col >= 0; col--) positions.push(perimeterPosition(bottomIdx, col, width, bottomIdx));
+	for (let row = bottomIdx - 1; row >= 1; row--) positions.push(perimeterPosition(row, 0, width, bottomIdx));
+	return positions;
+}
+
+test("the perimeter walk covers every border cell exactly once, in order", () => {
+	for (const [width, bottomIdx] of [
+		[10, 5],
+		[12, 2],
+		[5, 5],
+	] as const) {
+		const P = perimeterLength(width, bottomIdx);
+		const positions = walkPositions(width, bottomIdx);
+		assert.equal(positions.length, P, `expected ${P} border cells`);
+		assert.equal(new Set(positions).size, P, "walk visits a position twice");
+		for (const [i, p] of positions.entries()) {
+			const prev = positions[(i - 1 + P) % P]!;
+			assert.equal((p - prev + P) % P, 1, `step ${i} is not consecutive with its neighbour`);
+		}
+	}
+});
+
+test("colorChar wraps the glyph in per-char ANSI and resets", () => {
+	const rainbow = new RainbowBorder(0);
+	assert.match(rainbow.colorChar("─", 0, 28), /^\x1b\[38;(2;\d+;\d+;\d+|5;\d+)m─\x1b\[39m$/);
+});
+
+test("far-apart perimeter positions get different hues", () => {
+	const rainbow = new RainbowBorder(0);
+	// Opposite sides of a 28-cell perimeter are 180° of hue apart.
+	assert.notEqual(rainbow.colorChar("─", 0, 28), rainbow.colorChar("─", 14, 28));
+});
+
+test("step wraps the phase modulo 360", () => {
+	const a = new RainbowBorder(0);
+	const b = new RainbowBorder(0);
+	a.step(361);
+	b.step(1);
+	assert.equal(a.colorChar("─", 0, 28), b.colorChar("─", 0, 28));
+});
+
+test("the gap callback receives the absolute gap column and row", () => {
+	const calls: Array<{ str: string; startCol: number; row: number }> = [];
+	buildStatusLine(
+		80,
+		BASE,
+		resolveEffectiveSettings({}),
+		(str, startCol, row) => {
+			calls.push({ str, startCol, row });
+			return str;
+		},
+		{ left: [], right: ["pi"] },
+		{ col: 3, row: 7 },
+	);
+	assert.equal(calls.length, 1);
+	const call = calls[0]!;
+	assert.equal(call.row, 7);
+	// No left group: the gap starts at the bar origin.
+	assert.equal(call.startCol, 3);
+	assert.ok(call.str.includes(theme.getBox("rounded").horizontal));
+});
+
+test("a left group shifts the gap start by its width", () => {
+	const calls: Array<{ startCol: number }> = [];
+	buildStatusLine(
+		80,
+		BASE,
+		resolveEffectiveSettings({}),
+		(str, startCol) => {
+			calls.push({ startCol });
+			return str;
+		},
+		{ left: ["pi"], right: [] },
+		{ col: 3, row: 0 },
+	);
+	assert.equal(calls.length, 1);
+	assert.ok(calls[0]!.startCol > 3, "gap starts after the pi segment, not at the origin");
+});
+
+test("rainbowBorder defaults to true and is loadable", () => {
+	assert.equal(resolveEffectiveSettings({}).rainbowBorder, true);
+	assert.equal(resolveEffectiveSettings({ rainbowBorder: false }).rainbowBorder, false);
+});
+
+test("borderStyle defaults to rounded and is loadable", () => {
+	assert.equal(resolveEffectiveSettings({}).borderStyle, "rounded");
+	assert.equal(resolveEffectiveSettings({ borderStyle: "heavy" }).borderStyle, "heavy");
+});
+
+test("getBox falls back to the ascii box regardless of style under the ascii preset", () => {
+	theme.setSymbolPreset("ascii");
+	try {
+		assert.equal(theme.getBox("heavy").topLeft, "+");
+	} finally {
+		theme.setSymbolPreset("nerd");
+	}
+});