@underactive/pi-topping-statusline 0.1.0

package/src/settings-menu.ts

@@ -0,0 +1,370 @@
+/**
+ * The /topping-statusline-settings command: menu sections for the settings
+ * model, a live preview that renders the real box bars with the un-applied
+ * menu values, and the command registration.
+ */
+import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import type { SegmentContextBuilder } from "./context.js";
+import { buildStatusLine } from "./layout.js";
+import { showMenu, type MenuSection, type MenuValue, type PreviewResult } from "./menu.js";
+import {
+	perimeterLength,
+	perimeterPosition,
+	RAINBOW_CYCLE_MS,
+	RAINBOW_FRAME_MS,
+	RainbowBorder,
+} from "./rainbow.js";
+import {
+	applySettings,
+	BORDER_STYLES,
+	DEFAULT_FEEDS,
+	DEFAULT_SEGMENTS,
+	FEED_FORMATS,
+	resolveEffectiveSettings,
+	saveSettings,
+	sanitizeFeeds,
+	SEPARATORS,
+	type SettingsState,
+} from "./settings.js";
+import { theme, type BorderStyle, type SymbolPreset } from "./theme.js";
+import type {
+	FeedFormat,
+	SegmentContext,
+	SegmentIncludes,
+	StatusLineFeed,
+	StatusLineSegmentToggles,
+	StatusLineSeparatorStyle,
+	StatusLineSettings,
+} from "./types.js";
+
+const SYMBOL_LABELS: Record<SymbolPreset, string> = { nerd: "nerdfont", unicode: "unicode", ascii: "ascii" };
+const SYMBOL_FROM_LABEL: Record<string, SymbolPreset> = { nerdfont: "nerd", unicode: "unicode", ascii: "ascii" };
+const SYMBOL_VALUES: readonly string[] = ["nerdfont", "unicode", "ascii"];
+
+const SECTION_TITLES = [
+	"Top Left Segment Group",
+	"Top Right Segment Group",
+	"Bottom Right Segment Group",
+	"Bottom Left Segment Group",
+] as const;
+
+const SEGMENT_ROWS: readonly {
+	id: keyof StatusLineSegmentToggles;
+	label: string;
+	section: (typeof SECTION_TITLES)[number];
+}[] = [
+	{ id: "pi", label: "Pi symbol", section: "Top Left Segment Group" },
+	{ id: "model", label: "Model", section: "Top Left Segment Group" },
+	{ id: "provider", label: "Provider", section: "Top Left Segment Group" },
+	{ id: "thinking", label: "Thinking level", section: "Top Left Segment Group" },
+	{ id: "path", label: "Path", section: "Top Left Segment Group" },
+	{ id: "git", label: "Git", section: "Top Left Segment Group" },
+	{ id: "pr", label: "PR", section: "Top Left Segment Group" },
+	{ id: "tokenRateTopRight", label: "Token rate", section: "Top Right Segment Group" },
+	{ id: "sessionName", label: "Session name", section: "Top Right Segment Group" },
+	{ id: "feeds", label: "Feeds", section: "Bottom Right Segment Group" },
+	{ id: "tokenRate", label: "Token rate", section: "Bottom Right Segment Group" },
+	{ id: "piStats", label: "Pi stats", section: "Bottom Right Segment Group" },
+	{ id: "contextBar", label: "Context bar", section: "Bottom Right Segment Group" },
+	{ id: "contextStats", label: "Context stats", section: "Bottom Right Segment Group" },
+	{ id: "scrollHint", label: "Scroll hint", section: "Bottom Left Segment Group" },
+	{ id: "feedsBottomLeft", label: "Feeds", section: "Bottom Left Segment Group" },
+	{ id: "tokenRateBottomLeft", label: "Token rate", section: "Bottom Left Segment Group" },
+];
+
+// Feed rows are addressed by index so a rebuild can drop one cleanly.
+const FEED_PREFIX = "feed";
+const feedKey = (index: number, part: keyof StatusLineFeed) => `${FEED_PREFIX}.${index}.${part}`;
+const ADD_FEED_ID = `${FEED_PREFIX}.add`;
+const removeFeedId = (index: number) => `${FEED_PREFIX}.${index}.remove`;
+const FEED_ROW_RE = new RegExp(`^${FEED_PREFIX}\\.(\\d+)\\.`);
+
+function feedSection(feeds: readonly StatusLineFeed[]): MenuSection {
+	const items: MenuSection["items"] = [];
+	for (const [index, feed] of feeds.entries()) {
+		const n = index + 1;
+		items.push(
+			{ id: feedKey(index, "customType"), label: `${n}. type`, value: feed.customType, text: true, placeholder: "ext/custom-type" },
+			{ id: feedKey(index, "field"), label: `${n}. field`, value: feed.field, text: true, placeholder: "fieldName" },
+			{ id: feedKey(index, "prefix"), label: `${n}. prefix`, value: feed.prefix, text: true, placeholder: "(none)" },
+			{ id: feedKey(index, "format"), label: `${n}. format`, value: feed.format, cycleValues: FEED_FORMATS },
+			{ id: removeFeedId(index), label: `${n}. remove this feed`, value: false, action: true },
+		);
+	}
+	items.push({ id: ADD_FEED_ID, label: "+ add feed", value: false, action: true });
+	return { title: "Feeds", items };
+}
+
+/** Read the feed rows back out of the menu's flat value map. */
+function feedsFromValues(values: Record<string, MenuValue>): StatusLineFeed[] {
+	const indices = new Set<number>();
+	for (const key of Object.keys(values)) {
+		const match = FEED_ROW_RE.exec(key);
+		if (match) indices.add(Number(match[1]));
+	}
+	return [...indices]
+		.sort((a, b) => a - b)
+		.map((index): StatusLineFeed => {
+			const rawFormat = String(values[feedKey(index, "format")] ?? "text");
+			return {
+				customType: String(values[feedKey(index, "customType")] ?? ""),
+				field: String(values[feedKey(index, "field")] ?? ""),
+				prefix: String(values[feedKey(index, "prefix")] ?? ""),
+				format: FEED_FORMATS.includes(rawFormat as FeedFormat) ? (rawFormat as FeedFormat) : "text",
+			};
+		})
+		.filter(feed => feed.customType.trim() || feed.field.trim() || feed.prefix.trim());
+}
+
+function buildSections(settings: StatusLineSettings): MenuSection[] {
+	const seg = { ...DEFAULT_SEGMENTS, ...settings.segments };
+	const global: MenuSection = {
+		title: "Global",
+		items: [
+			{ id: "transparent", label: "Transparent Segments", value: settings.transparent ?? true },
+			{
+				id: "separator",
+				label: "Separator",
+				value: settings.separator ?? "powerline-thin",
+				cycleValues: SEPARATORS,
+			},
+			{ id: "symbols", label: "Symbols", value: SYMBOL_LABELS[settings.symbols ?? "nerd"], cycleValues: SYMBOL_VALUES },
+			{
+				id: "borderStyle",
+				label: "Border style",
+				value: settings.borderStyle ?? "rounded",
+				cycleValues: BORDER_STYLES,
+			},
+			{
+				id: "rainbowBorder",
+				label: "Rainbow border on max thinking",
+				value: settings.rainbowBorder ?? true,
+			},
+		],
+	};
+	return [
+		global,
+		...SECTION_TITLES.map(title => ({
+			title,
+			items: SEGMENT_ROWS.filter(row => row.section === title).map(row => ({
+				id: row.id,
+				label: row.label,
+				value: seg[row.id],
+			})),
+		})),
+		feedSection(settings.feeds ? sanitizeFeeds(settings.feeds) : DEFAULT_FEEDS),
+	];
+}
+
+function valuesToSettings(values: Record<string, MenuValue>): StatusLineSettings {
+	const segments: StatusLineSegmentToggles = {};
+	for (const row of SEGMENT_ROWS) segments[row.id] = values[row.id] === true;
+	const separator = values.separator as StatusLineSeparatorStyle;
+	const borderStyle = values.borderStyle as BorderStyle;
+	return {
+		transparent: values.transparent === true,
+		separator: SEPARATORS.includes(separator) ? separator : "powerline-thin",
+		symbols: SYMBOL_FROM_LABEL[values.symbols as string] ?? "nerd",
+		borderStyle: BORDER_STYLES.includes(borderStyle) ? borderStyle : "rounded",
+		segments,
+		feeds: sanitizeFeeds(feedsFromValues(values)),
+		rainbowBorder: values.rainbowBorder === true,
+	};
+}
+
+// Canned stand-ins keep every toggle visible in the preview even when the
+// live session lacks the data (no PR, no scrollback, fresh session).
+const CANNED_PR = { number: 42, url: "https://github.com/underactive/pi-topping-statusline/pull/42" };
+const CANNED_TOKEN_RATE = { rate: 87, phase: "active", fadeShade: 0 } as const;
+/** Stand-in payloads so configured feeds still preview without a live publisher. */
+const CANNED_FEED_NUMBER = 1.23;
+const CANNED_HINT = "↑ 3 more";
+const CANNED_STATS = "↑ 12.4K ↓ 3.1K R 148K W 12K 92.3% $0.42";
+const CANNED_GIT = { branch: "main", status: { staged: 1, unstaged: 2, untracked: 3 } };
+const CANNED_PERCENT = 42;
+const CANNED_WINDOW = 200_000;
+
+/** Fill any feed the live session has no entry for, so the preview stays legible. */
+function cannedFeedData(
+	feeds: readonly StatusLineFeed[],
+	live: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+	const data: Record<string, unknown> = { ...live };
+	for (const feed of feeds) {
+		if (data[feed.customType] !== undefined || !feed.field) continue;
+		data[feed.customType] = {
+			[feed.field]: feed.format === "text" ? "sample" : CANNED_FEED_NUMBER,
+		};
+	}
+	return data;
+}
+
+class StatusLinePreview {
+	readonly #state: SettingsState;
+	readonly #builder: SegmentContextBuilder;
+	readonly #uiTheme: Theme;
+
+	constructor(state: SettingsState, builder: SegmentContextBuilder, uiTheme: Theme) {
+		this.#state = state;
+		this.#builder = builder;
+		this.#uiTheme = uiTheme;
+	}
+
+	render(
+		values: Record<string, MenuValue>,
+		elapsedMs: number,
+		_activeItemId: string | undefined,
+		innerWidth: number,
+	): PreviewResult {
+		const effective = resolveEffectiveSettings(valuesToSettings(values));
+		// Preview lines are indented one cell by the menu; mirror renderBoxed's
+		// 6-cell chrome budget for the bars themselves.
+		const boxWidth = Math.max(24, innerWidth - 1);
+		const barWidth = boxWidth - 6;
+		const rainbowOn = effective.rainbowBorder;
+
+		// The theme singleton drives glyph lookups everywhere, so swap the
+		// symbol preset for this synchronous render only; the live bar behind
+		// the overlay keeps the applied preset.
+		const applied = this.#state.effective.symbols;
+		theme.setSymbolPreset(effective.symbols);
+		try {
+			const include: SegmentIncludes = {
+				git: true,
+				pr: true,
+				piStats: true,
+				tokenRate: true,
+				feeds: effective.segmentOptions.feeds.map(f => f.customType),
+			};
+			const base = this.#builder.build(barWidth, effective.segmentOptions, include, CANNED_HINT);
+			const contextWindow = base.contextWindow || CANNED_WINDOW;
+			const ctx: SegmentContext = {
+				...base,
+				// The preview demos the rainbow whenever the toggle is on,
+				// regardless of the live session's thinking level.
+				thinkingLevel: rainbowOn ? "max" : base.thinkingLevel,
+				git: {
+					branch: base.git.branch ?? CANNED_GIT.branch,
+					status: base.git.status ?? CANNED_GIT.status,
+					pr: base.git.pr ?? CANNED_PR,
+				},
+				contextPercent: base.contextPercent ?? CANNED_PERCENT,
+				contextTokens: base.contextPercent == null ? Math.round((contextWindow * CANNED_PERCENT) / 100) : base.contextTokens,
+				contextWindow,
+				piStats: base.piStats ?? CANNED_STATS,
+				tokenRate: base.tokenRate ?? CANNED_TOKEN_RATE,
+				feedData: cannedFeedData(effective.segmentOptions.feeds, base.feedData),
+			};
+
+			const box = theme.getBox(effective.borderStyle);
+			const staticBorder = (s: string, _startCol: number, _row: number) => this.#uiTheme.fg("border", s);
+			// The preview box is three rows tall: top bar, side verticals, bottom bar.
+			const bottomIdx = 2;
+			const rainbow = new RainbowBorder((elapsedMs * 360) / RAINBOW_CYCLE_MS);
+			const perimeter = perimeterLength(boxWidth, bottomIdx);
+			const paint = (row: number, col: number, ch: string): string =>
+				rainbowOn
+					? rainbow.colorChar(ch, perimeterPosition(row, col, boxWidth, bottomIdx), perimeter)
+					: staticBorder(ch, col, row);
+			const horizRun = (row: number, startCol: number, count: number): string => {
+				let out = "";
+				for (let k = 0; k < count; k++) out += paint(row, startCol + k, box.horizontal);
+				return out;
+			};
+			const gapColor = (str: string, startCol: number, row: number): string =>
+				rainbowOn ? [...str].map((ch, k) => paint(row, startCol + k, ch)).join("") : staticBorder(str, startCol, row);
+			const row = (bar: string, rowIdx: number, left: string, right: string): string => {
+				const pad = Math.max(0, barWidth - visibleWidth(bar));
+				return (
+					paint(rowIdx, 0, left) +
+					horizRun(rowIdx, 1, 2) +
+					bar +
+					horizRun(rowIdx, 3 + visibleWidth(bar), pad + 2) +
+					paint(rowIdx, boxWidth - 1, right)
+				);
+			};
+			const top = buildStatusLine(
+				barWidth,
+				ctx,
+				effective,
+				gapColor,
+				{
+					left: effective.leftSegments,
+					right: effective.rightSegments,
+				},
+				{ col: 3, row: 0 },
+			);
+			const bottom = buildStatusLine(
+				barWidth,
+				ctx,
+				effective,
+				gapColor,
+				{
+					left: effective.bottomLeftSegments,
+					right: effective.bottomRightSegments,
+				},
+				{ col: 3, row: bottomIdx },
+			);
+			return {
+				lines: [
+					row(top, 0, box.topLeft, box.topRight),
+					paint(1, 0, box.vertical) + " ".repeat(Math.max(0, boxWidth - 2)) + paint(1, boxWidth - 1, box.vertical),
+					row(bottom, bottomIdx, box.bottomLeft, box.bottomRight),
+				],
+				// Keep the preview animated only while the rainbow is enabled;
+				// a static preview refreshes once and stops.
+				nextRefreshInMs: rainbowOn ? RAINBOW_FRAME_MS : undefined,
+			};
+		} finally {
+			theme.setSymbolPreset(applied);
+		}
+	}
+}
+
+export function registerSettingsCommand(
+	pi: ExtensionAPI,
+	state: SettingsState,
+	builder: SegmentContextBuilder,
+	onChange: () => void,
+): void {
+	pi.registerCommand("topping-statusline-settings", {
+		description: "Configure transparent segments, statusline segments, separator, symbols, border style, feeds, and rainbow border",
+		handler: async (_args, ctx: ExtensionCommandContext) => {
+			if (ctx.mode !== "tui") {
+				ctx.ui.notify("/topping-statusline-settings requires TUI mode", "error");
+				return;
+			}
+			const preview = new StatusLinePreview(state, builder, ctx.ui.theme);
+			const result = await showMenu<Record<string, MenuValue>>(ctx, {
+				title: "Pi Topping Statusline: Settings",
+				sections: buildSections(state.settings),
+				hints: ["↑↓ move", "←→ cycle", "␣ toggle", "⏎ apply/edit", "esc cancel"],
+				preview: preview.render.bind(preview),
+				onAction: (id, values) => {
+					const feeds = feedsFromValues(values);
+					if (id === ADD_FEED_ID) {
+						feeds.push({ customType: "", field: "", prefix: "", format: "currency" });
+					} else {
+						const match = new RegExp(`^${FEED_PREFIX}\\.(\\d+)\\.remove$`).exec(id);
+						if (!match) return undefined;
+						feeds.splice(Number(match[1]), 1);
+					}
+					// Rows are index-addressed, so the whole menu is regenerated to
+					// keep ids contiguous after an insert or removal.
+					return [...buildSections(valuesToSettings(values)).slice(0, -1), feedSection(feeds)];
+				},
+			});
+			if (!result.applied) return;
+			const next = valuesToSettings(result.values);
+			applySettings(state, next);
+			onChange();
+			try {
+				saveSettings(next);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				ctx.ui.notify(`Failed to save statusline settings: ${message}`, "error");
+			}
+		},
+	});
+}

package/src/settings.ts

@@ -0,0 +1,169 @@
+/**
+ * Settings persistence. Pi has no per-extension settings store, so the
+ * statusline settings live in a small JSON at
+ * ~/.pi/agent/pi-topping-statusline/settings.json.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { theme, type BorderStyle, type SymbolPreset } from "./theme.js";
+import type {
+	EffectiveStatusLineSettings,
+	FeedFormat,
+	StatusLineFeed,
+	StatusLineSegmentId,
+	StatusLineSegmentToggles,
+	StatusLineSeparatorStyle,
+	StatusLineSettings,
+} from "./types.js";
+
+const SETTINGS_PATH = path.join(getAgentDir(), "pi-topping-statusline", "settings.json");
+
+export const SEPARATORS: readonly StatusLineSeparatorStyle[] = ["powerline", "powerline-thin", "slash", "pipe", "ascii"];
+const SYMBOL_PRESETS: SymbolPreset[] = ["nerd", "unicode", "ascii"];
+export const BORDER_STYLES: readonly BorderStyle[] = ["rounded", "heavy", "double", "single"];
+
+export const FEED_FORMATS: readonly FeedFormat[] = ["currency", "number", "text"];
+
+/**
+ * Seeded with pi-prompt-cache's published savings feed, so the segment works
+ * as soon as it is switched on and doubles as a worked example of the shape.
+ */
+export const DEFAULT_FEEDS: readonly StatusLineFeed[] = [
+	{ customType: "pi-prompt-cache/savings", field: "savedUsd", prefix: "CS", format: "currency" },
+];
+
+export const DEFAULT_SEGMENTS: Required<StatusLineSegmentToggles> = {
+	pi: true,
+	model: true,
+	provider: false,
+	thinking: true,
+	path: true,
+	git: true,
+	pr: true,
+	sessionName: true,
+	tokenRateTopRight: false,
+	piStats: true,
+	tokenRate: false,
+	feeds: false,
+	feedsBottomLeft: false,
+	tokenRateBottomLeft: false,
+	contextBar: true,
+	contextStats: true,
+	scrollHint: true,
+};
+
+const SEGMENT_KEYS = Object.keys(DEFAULT_SEGMENTS) as (keyof StatusLineSegmentToggles)[];
+
+/** Keep only well-formed rows; a feed without a customType or field can render nothing. */
+export function sanitizeFeeds(raw: unknown): StatusLineFeed[] {
+	if (!Array.isArray(raw)) return [];
+	const feeds: StatusLineFeed[] = [];
+	for (const item of raw) {
+		if (!item || typeof item !== "object") continue;
+		const { customType, field, prefix, format } = item as Record<string, unknown>;
+		if (typeof customType !== "string" || typeof field !== "string") continue;
+		if (!customType.trim() || !field.trim()) continue;
+		feeds.push({
+			customType: customType.trim(),
+			field: field.trim(),
+			prefix: typeof prefix === "string" ? prefix : "",
+			format: FEED_FORMATS.includes(format as FeedFormat) ? (format as FeedFormat) : "text",
+		});
+	}
+	return feeds;
+}
+
+function loadSettings(): StatusLineSettings {
+	try {
+		const raw = JSON.parse(fs.readFileSync(SETTINGS_PATH, "utf8")) as StatusLineSettings;
+		const settings: StatusLineSettings = {};
+		if (typeof raw.transparent === "boolean") settings.transparent = raw.transparent;
+		if (raw.separator && SEPARATORS.includes(raw.separator)) settings.separator = raw.separator;
+		if (raw.symbols && SYMBOL_PRESETS.includes(raw.symbols)) settings.symbols = raw.symbols;
+		if (raw.borderStyle && BORDER_STYLES.includes(raw.borderStyle)) settings.borderStyle = raw.borderStyle;
+		if (raw.segments && typeof raw.segments === "object") {
+			const segments: StatusLineSegmentToggles = {};
+			for (const key of SEGMENT_KEYS) {
+				if (typeof raw.segments[key] === "boolean") segments[key] = raw.segments[key];
+			}
+			settings.segments = segments;
+		}
+		if (raw.feeds !== undefined) settings.feeds = sanitizeFeeds(raw.feeds);
+		if (typeof raw.rainbowBorder === "boolean") settings.rainbowBorder = raw.rainbowBorder;
+		return settings;
+	} catch {
+		return {};
+	}
+}
+
+/** Atomic write; throws so callers can surface the failure. */
+export function saveSettings(settings: StatusLineSettings): void {
+	fs.mkdirSync(path.dirname(SETTINGS_PATH), { recursive: true });
+	fs.writeFileSync(`${SETTINGS_PATH}.tmp`, `${JSON.stringify(settings, null, "\t")}\n`, { mode: 0o600 });
+	fs.renameSync(`${SETTINGS_PATH}.tmp`, SETTINGS_PATH);
+	fs.chmodSync(SETTINGS_PATH, 0o600);
+}
+
+export function resolveEffectiveSettings(settings: StatusLineSettings): EffectiveStatusLineSettings {
+	const seg = { ...DEFAULT_SEGMENTS, ...settings.segments };
+
+	const leftSegments: StatusLineSegmentId[] = [];
+	if (seg.pi) leftSegments.push("pi");
+	if (seg.model || seg.provider || seg.thinking) leftSegments.push("model");
+	if (seg.path) leftSegments.push("path");
+	if (seg.git) leftSegments.push("git");
+	if (seg.pr) leftSegments.push("pr");
+
+	const bottomRightSegments: StatusLineSegmentId[] = [];
+	if (seg.feeds) bottomRightSegments.push("feeds");
+	if (seg.tokenRate) bottomRightSegments.push("token_rate");
+	if (seg.piStats) bottomRightSegments.push("pi_stats");
+	if (seg.contextBar || seg.contextStats) bottomRightSegments.push("context_graph");
+
+	const rightSegments: StatusLineSegmentId[] = [];
+	// The rate leads so its width changes never shift the session name.
+	if (seg.tokenRateTopRight) rightSegments.push("token_rate");
+	if (seg.sessionName) rightSegments.push("session_name");
+
+	const bottomLeftSegments: StatusLineSegmentId[] = [];
+	if (seg.scrollHint) bottomLeftSegments.push("scroll_hint");
+	if (seg.feedsBottomLeft) bottomLeftSegments.push("feeds");
+	if (seg.tokenRateBottomLeft) bottomLeftSegments.push("token_rate");
+
+	return {
+		transparent: settings.transparent ?? true,
+		separator: settings.separator ?? "powerline-thin",
+		symbols: settings.symbols ?? "nerd",
+		borderStyle: settings.borderStyle ?? "rounded",
+		leftSegments,
+		rightSegments,
+		bottomLeftSegments,
+		bottomRightSegments,
+		rainbowBorder: settings.rainbowBorder ?? true,
+		segmentOptions: {
+			model: { showModel: seg.model, showProvider: seg.provider, showThinking: seg.thinking },
+			path: { abbreviate: true, maxLength: 40, stripWorkPrefix: true },
+			context: { showBar: seg.contextBar, showStats: seg.contextStats },
+			feeds: settings.feeds ? sanitizeFeeds(settings.feeds) : [...DEFAULT_FEEDS],
+		},
+	};
+}
+
+export interface SettingsState {
+	settings: StatusLineSettings;
+	effective: EffectiveStatusLineSettings;
+}
+
+export function applySettings(state: SettingsState, settings: StatusLineSettings): void {
+	state.settings = settings;
+	state.effective = resolveEffectiveSettings(settings);
+	theme.setSymbolPreset(state.effective.symbols);
+}
+
+export function createSettingsState(): SettingsState {
+	const settings = loadSettings();
+	const effective = resolveEffectiveSettings(settings);
+	theme.setSymbolPreset(effective.symbols);
+	return { settings, effective };
+}

package/src/tests/context-thresholds.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Context threshold bands: percent vs. token-derived caps, and
+ * formatContextUsage's unknown-window/unknown-percent rendering.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import { formatContextUsage, getContextUsageLevel } from "../context-thresholds.ts";
+
+test("percent bands trigger at 50/70/90 when the window is small enough that token caps don't bind first", () => {
+	const window = 200_000;
+	assert.equal(getContextUsageLevel(49.9, window), "normal");
+	assert.equal(getContextUsageLevel(50, window), "warning");
+	assert.equal(getContextUsageLevel(69.9, window), "warning");
+	assert.equal(getContextUsageLevel(70, window), "elevated");
+	assert.equal(getContextUsageLevel(89.9, window), "elevated");
+	assert.equal(getContextUsageLevel(90, window), "error");
+});
+
+test("a large window makes the token thresholds bind before the percent thresholds", () => {
+	const window = 1_000_000;
+	assert.equal(getContextUsageLevel(14.9, window), "normal");
+	assert.equal(getContextUsageLevel(15, window), "warning");
+	assert.equal(getContextUsageLevel(27, window), "elevated");
+	assert.equal(getContextUsageLevel(50, window), "error");
+});
+
+test("an unknown window (<=0) falls back to the raw percent thresholds", () => {
+	assert.equal(getContextUsageLevel(49, 0), "normal");
+	assert.equal(getContextUsageLevel(50, 0), "warning");
+	assert.equal(getContextUsageLevel(90, -1), "error");
+});
+
+test("zero or negative percent never crosses any threshold", () => {
+	assert.equal(getContextUsageLevel(0, 200_000), "normal");
+	assert.equal(getContextUsageLevel(-5, 200_000), "normal");
+});
+
+test("an unknown window falls back to the raw token count", () => {
+	assert.equal(formatContextUsage(42, 0, 1234), "1.2K/?");
+	assert.equal(formatContextUsage(42, 0, undefined), "0/?");
+});
+
+test("a null or undefined percent against a known window renders '?'", () => {
+	assert.equal(formatContextUsage(null, 200_000, 1000), "?/200K");
+	assert.equal(formatContextUsage(undefined, 200_000, 1000), "?/200K");
+});
+
+test("a known percent renders with one decimal", () => {
+	assert.equal(formatContextUsage(42.567, 200_000), "42.6%/200K");
+});