@oh-my-pi/pi-tui 18.2.3 → 18.2.5

package/src/status-line/footer.ts

@@ -0,0 +1,323 @@
+import { stripVTControlCharacters } from "node:util";
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import * as vcs from "@oh-my-pi/pi-natives/vcs";
+import { type Component, padding, truncateToWidth, visibleWidth } from "../index";
+import { formatNumber, getProjectDir } from "@oh-my-pi/pi-utils";
+import { theme } from "../theme";
+import type { FooterHost, FooterSession } from "./host";
+import { shortenPath } from "../render/render-utils";
+import { sanitizeStatusText } from "../chrome/shared";
+import { formatMetric } from "../components/metric";
+import { formatBillingSummary } from "./metrics";
+import { formatContextUsage, getContextUsageLevel, getContextUsageThemeColor } from "../chrome/context-thresholds";
+
+/**
+ * Footer component that shows pwd, token stats, and context usage
+ */
+export class FooterComponent implements Component {
+	#cachedBranch: string | null | undefined = undefined;
+	#branchResolve: AbortController | undefined;
+	#branchGeneration = 0;
+	#gitUnwatch: (() => void) | null = null;
+	#onBranchChange: (() => void) | null = null;
+	#disposed = false;
+	#autoCompactEnabled: boolean = true;
+	#extensionStatuses: Map<string, string> = new Map();
+
+	constructor(
+		private readonly session: FooterSession,
+		private readonly host: FooterHost,
+	) {}
+
+	setAutoCompactEnabled(enabled: boolean): void {
+		this.#autoCompactEnabled = enabled;
+	}
+
+	/**
+	 * Set extension status text to display in the footer.
+	 * ANSI/VT escape sequences and most control characters are stripped; tabs and newlines become spaces.
+	 * The combined status line is trimmed and truncated to terminal width.
+	 * @param key - Unique key to identify this status
+	 * @param text - Status text, or undefined to clear
+	 */
+	setExtensionStatus(key: string, text: string | undefined): void {
+		if (text === undefined) {
+			this.#extensionStatuses.delete(key);
+		} else {
+			this.#extensionStatuses.set(key, text);
+		}
+	}
+
+	/**
+	 * Watch the repository head for label changes and repaint the footer.
+	 */
+	watchBranch(onBranchChange: () => void): void {
+		this.#onBranchChange = onBranchChange;
+		this.#setupGitWatcher();
+	}
+
+	#setupGitWatcher(): void {
+		this.#gitUnwatch?.();
+		this.#gitUnwatch = null;
+
+		if (!this.host.gitEnabled()) return;
+		const repository = vcs.repoForDisplay(getProjectDir());
+		if (!repository) return;
+
+		try {
+			this.#gitUnwatch = vcs.watch(repository, () => {
+				this.#invalidateBranch();
+				this.#onBranchChange?.();
+			});
+		} catch {
+			// Silently fail if we can't watch
+		}
+	}
+
+	/**
+	 * Clean up the file watcher
+	 */
+	dispose(): void {
+		this.#disposed = true;
+		this.#branchResolve?.abort();
+		this.#branchResolve = undefined;
+		this.#gitUnwatch?.();
+		this.#gitUnwatch = null;
+	}
+
+	invalidate(): void {
+		this.#invalidateBranch();
+	}
+
+	#invalidateBranch(): void {
+		this.#branchGeneration++;
+		this.#branchResolve?.abort();
+		this.#branchResolve = undefined;
+		this.#cachedBranch = undefined;
+	}
+
+	/**
+	 * Get the current branch, bookmark, or change-id label.
+	 */
+	#getCurrentBranch(): string | null {
+		if (!this.host.gitEnabled()) return null;
+		if (this.#cachedBranch !== undefined) {
+			return this.#cachedBranch;
+		}
+
+		const repository = (() => {
+			try {
+				return vcs.repoForDisplay(getProjectDir());
+			} catch {
+				return null;
+			}
+		})();
+		if (!repository) {
+			this.#cachedBranch = null;
+			return null;
+		}
+
+		const gitRepository = repository.asGit();
+		if (!gitRepository) {
+			if (!this.#branchResolve) {
+				const request = new AbortController();
+				const generation = this.#branchGeneration;
+				this.#branchResolve = request;
+				void repository
+					.label(request.signal)
+					.then(label => {
+						if (this.#disposed || this.#branchGeneration !== generation) return;
+						const clean = typeof label === "string" ? sanitizeStatusText(label) : label;
+						const changed = this.#cachedBranch !== clean;
+						this.#cachedBranch = clean;
+						if (changed) this.#onBranchChange?.();
+					})
+					.catch(() => {
+						if (this.#disposed || this.#branchGeneration !== generation) return;
+						this.#cachedBranch = null;
+					})
+					.finally(() => {
+						if (this.#branchResolve === request) this.#branchResolve = undefined;
+					});
+			}
+			return this.#cachedBranch ?? null;
+		}
+
+		const headState = (() => {
+			try {
+				return gitRepository.headSync();
+			} catch {
+				return null;
+			}
+		})();
+		this.#cachedBranch =
+			headState === null
+				? null
+				: headState.kind === "ref"
+					? (headState.branch ?? headState.refName ?? "HEAD")
+					: "detached";
+		return this.#cachedBranch;
+	}
+
+	render(width: number): readonly string[] {
+		const state = this.session.state;
+
+		// Calculate cumulative usage from ALL session entries (not just post-compaction messages)
+		let totalInput = 0;
+		let totalOutput = 0;
+		let totalCacheRead = 0;
+		let totalCacheWrite = 0;
+		let totalCost = 0;
+		let totalPremiumRequests = 0;
+
+		for (const entry of this.session.sessionManager.getEntries()) {
+			if (entry.type === "message" && entry.message?.role === "assistant") {
+				totalInput += entry.message.usage.input;
+				totalOutput += entry.message.usage.output;
+				totalCacheRead += entry.message.usage.cacheRead;
+				totalCacheWrite += entry.message.usage.cacheWrite;
+				totalCost += entry.message.usage.cost.total;
+				totalPremiumRequests += entry.message.usage.premiumRequests ?? 0;
+			}
+		}
+
+		// Calculate context usage from session (handles compaction correctly).
+		// After compaction, tokens are unknown until the next LLM response.
+		const contextUsage = this.session.getContextUsage();
+		const contextWindow = contextUsage?.contextWindow ?? state.model?.contextWindow ?? 0;
+		const contextTokens = contextUsage?.tokens ?? 0;
+		const contextPercentValue = contextWindow > 0 ? (contextUsage?.percent ?? 0) : null;
+
+		// Replace home directory with ~
+		let pwd = shortenPath(getProjectDir());
+
+		// Add git branch if available
+		const branch = this.#getCurrentBranch();
+		if (branch) {
+			pwd = `${pwd} (${branch})`;
+		}
+
+		// Truncate path if too long to fit width
+		if (pwd.length > width) {
+			const half = Math.floor(width / 2) - 1;
+			if (half > 1) {
+				const start = pwd.slice(0, half);
+				const end = pwd.slice(-(half - 1));
+				pwd = `${start}…${end}`;
+			} else {
+				pwd = pwd.slice(0, Math.max(1, width));
+			}
+		}
+
+		// Build stats line
+		const statsParts: string[] = [];
+		for (const [glyph, amount] of [
+			["↑", totalInput],
+			["↓", totalOutput],
+			["R", totalCacheRead],
+			["W", totalCacheWrite],
+		] as const) {
+			const part = formatMetric({
+				leading: glyph,
+				separator: "",
+				value: amount ? formatNumber(amount) : undefined,
+			});
+			if (part !== undefined) statsParts.push(part);
+		}
+
+		// Show billing summary with subscription and premium-request indicators
+		const usingSubscription = state.model ? this.session.modelRegistry.isUsingOAuth(state.model) : false;
+		const { auto: autoIcon } = theme.icon;
+		const billing = formatBillingSummary(
+			{ cost: totalCost, usingSubscription, premiumRequests: totalPremiumRequests, fractionDigits: 3 },
+			theme,
+		);
+		if (billing) statsParts.push(billing);
+		// Colorize context percentage based on usage
+		let contextPercentStr: string;
+		const autoIndicator = this.#autoCompactEnabled && autoIcon ? ` ${autoIcon}` : "";
+		const contextPercentDisplay = `${formatContextUsage(contextPercentValue, contextWindow, contextTokens)}${autoIndicator}`;
+		if (contextUsage && contextPercentValue !== null) {
+			const color = getContextUsageThemeColor(getContextUsageLevel(contextPercentValue, contextWindow));
+			contextPercentStr =
+				color === "statusLineContext" ? contextPercentDisplay : theme.fg(color, contextPercentDisplay);
+		} else {
+			contextPercentStr = contextPercentDisplay;
+		}
+		statsParts.push(contextPercentStr);
+
+		let statsLeft = statsParts.join(" ");
+
+		// Add model name on the right side, plus thinking level if model supports it
+		const modelName = state.model?.id || "no-model";
+
+		// Add thinking level hint when the current model advertises supported efforts
+		let rightSide = modelName;
+		if (state.model?.thinking) {
+			if (this.session.isAutoThinking) {
+				// Pending (no turn classified yet / classifying) shows a symbol-theme
+				// question-box marker; once resolved it shows `<level>`.
+				const resolved = this.session.autoResolvedThinkingLevel();
+				rightSide = `${modelName} • ${resolved ? resolved : `${theme.thinking.autoPending} auto`}`;
+			} else {
+				const thinkingLevel = state.thinkingLevel ?? ThinkingLevel.Off;
+				rightSide = `${modelName} • ${thinkingLevel}`;
+			}
+		}
+
+		let statsLeftWidth = visibleWidth(statsLeft);
+		const rightSideWidth = visibleWidth(rightSide);
+
+		// If statsLeft is too wide, truncate it
+		if (statsLeftWidth > width) {
+			// Drop styling and truncate by terminal cells (not code points) so wide
+			// glyphs and non-SGR escapes can't overflow the line.
+			statsLeft = truncateToWidth(stripVTControlCharacters(statsLeft), width);
+			statsLeftWidth = visibleWidth(statsLeft);
+		}
+
+		// Calculate available space for padding (minimum 2 spaces between stats and model)
+		const minPadding = 2;
+		const totalNeeded = statsLeftWidth + minPadding + rightSideWidth;
+
+		let statsLine: string;
+		if (totalNeeded <= width) {
+			// Both fit - add padding to right-align model
+			const pad = padding(width - statsLeftWidth - rightSideWidth);
+			statsLine = statsLeft + pad + rightSide;
+		} else {
+			// Need to truncate right side
+			const availableForRight = width - statsLeftWidth - minPadding;
+			if (availableForRight > 3) {
+				// Drop styling and truncate by terminal cells so the right side fits.
+				const truncatedRight = truncateToWidth(stripVTControlCharacters(rightSide), availableForRight);
+				const pad = padding(width - statsLeftWidth - visibleWidth(truncatedRight));
+				statsLine = statsLeft + pad + truncatedRight;
+			} else {
+				// Not enough space for right side at all
+				statsLine = statsLeft;
+			}
+		}
+
+		// Apply dim to each part separately. statsLeft may contain color codes (for context %)
+		// that end with a reset, which would clear an outer dim wrapper. So we dim the parts
+		// before and after the colored section independently.
+		const dimStatsLeft = theme.fg("dim", statsLeft);
+		const remainder = statsLine.slice(statsLeft.length); // padding + rightSide
+		const dimRemainder = theme.fg("dim", remainder);
+
+		const lines = [theme.fg("dim", pwd), dimStatsLeft + dimRemainder];
+
+		// Add extension statuses on a single line, sorted by key alphabetically
+		if (this.#extensionStatuses.size > 0) {
+			const sortedStatuses = Array.from(this.#extensionStatuses.entries())
+				.sort(([a], [b]) => a.localeCompare(b))
+				.map(([, text]) => sanitizeStatusText(text));
+			const statusLine = sortedStatuses.join(" ");
+			// Truncate to terminal width with dim ellipsis for consistency with footer style
+			lines.push(truncateToWidth(statusLine, width));
+		}
+
+		return lines;
+	}
+}

package/src/status-line/git-utils.ts

@@ -0,0 +1,42 @@
+/**
+ * Extract "owner/repo" from a GitHub remote URL.
+ * Handles HTTPS, SSH (scp-style), and git:// protocols.
+ *
+ * @returns "owner/repo" or null if the URL isn't a recognized GitHub remote.
+ */
+export function parseGitHubRepo(remoteUrl: string): string | null {
+	const match = remoteUrl.match(/github\.com[:/]([^/]+\/[^/]+)/);
+	if (!match) return null;
+	return match[1].replace(/\.git$/, "");
+}
+
+/**
+ * Extract the branch name from a remote HEAD ref like "origin/main".
+ * Returns the portion after the first "/" or the whole string if no "/" is present.
+ */
+export function parseDefaultBranch(ref: string): string {
+	const slash = ref.indexOf("/");
+	return slash >= 0 ? ref.slice(slash + 1) : ref;
+}
+
+export interface PrCacheContext {
+	branch: string;
+	repoId: string | null;
+}
+
+export function createPrCacheContext(branch: string, repoId: string | null): PrCacheContext {
+	return { branch, repoId };
+}
+
+export function isSamePrCacheContext(a: PrCacheContext | undefined, b: PrCacheContext | undefined): boolean {
+	if (!a || !b) return false;
+	return a.branch === b.branch && a.repoId === b.repoId;
+}
+
+export function canReuseCachedPr(
+	cachedPr: { number: number; url: string } | null | undefined,
+	cachedContext: PrCacheContext | undefined,
+	currentContext: PrCacheContext | null,
+): boolean {
+	return cachedPr !== undefined && currentContext !== null && isSamePrCacheContext(cachedContext, currentContext);
+}

package/src/status-line/host.ts

@@ -0,0 +1,97 @@
+import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Tool, UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import type { CompactionBoundaries } from "./context-usage";
+import type { StatusLineSettings } from "./types";
+
+export interface StatusAccountIdentity {
+	accountId?: string;
+	email?: string;
+	projectId?: string;
+	orgId?: string;
+}
+
+/** Nested repository selected as the active workspace context. */
+export interface ActiveRepoContext {
+	cwd: string;
+	repoRoot: string;
+	relativeRepoRoot: string;
+	source: "single-direct-child-repo";
+}
+
+export interface StatusLineSession {
+	state: { model?: Model; thinkingLevel?: ThinkingLevel; messages: readonly AgentMessage[] };
+	model?: Model;
+	messages?: readonly AgentMessage[];
+	sessionFile?: string;
+	isStreaming: boolean;
+	isAutoThinking: boolean;
+	contextUsageRevision?: number;
+	systemPrompt?: readonly string[];
+	agent?: { state?: { tools?: readonly Pick<Tool, "name" | "description" | "parameters">[] }; tokenizer?: unknown };
+	skills?: readonly unknown[];
+	compactionSpeculation?: "idle" | "running" | "armed";
+	sessionManager: {
+		getSessionName(): string | undefined;
+		getSessionId(): string;
+		getUsageStatistics(): {
+			input: number;
+			output: number;
+			cacheRead: number;
+			cacheWrite: number;
+			totalTokens: number;
+			orchestrationInput: number;
+			orchestrationOutput: number;
+			orchestrationCacheRead: number;
+			premiumRequests: number;
+			cost: number;
+		};
+	};
+	modelRegistry: {
+		isUsingOAuth(model: Model): boolean;
+	};
+	getContextUsage(): { tokens: number; contextWindow: number; percent: number | null } | undefined;
+	autoResolvedThinkingLevel(): string | undefined;
+	isFastModeActive(): boolean;
+	getPrewalkState?(): unknown;
+	getAsyncJobSnapshot(): { running: readonly { type: string; agentId?: string }[] } | null | undefined;
+	getGoalModeState(): { goal?: { status: string; tokensUsed: number; tokenBudget?: number } } | undefined;
+	getAdvisorStatusOverview?(): { configured: boolean; advisors: readonly { status: string; yielded: boolean }[] };
+	getAdvisorCost?(): number;
+	isAdvisorUsingSubscription?(): boolean;
+}
+
+export interface FooterSession {
+	state: Pick<StatusLineSession["state"], "model" | "thinkingLevel">;
+	isAutoThinking: boolean;
+	autoResolvedThinkingLevel(): string | undefined;
+	getContextUsage: StatusLineSession["getContextUsage"];
+	modelRegistry: Pick<StatusLineSession["modelRegistry"], "isUsingOAuth">;
+	sessionManager: { getEntries(): readonly { type: string; message?: AgentMessage }[] };
+}
+
+/**
+ * Runtime services stay in the host; renderers only consume these capabilities.
+ * `TSession` is the host's concrete session type (a structural superset of {@link StatusLineSession}).
+ */
+export interface StatusLineHost<TSession extends StatusLineSession = StatusLineSession> {
+	getSettings(): StatusLineSettings;
+	gitEnabled(): boolean;
+	codexResetFireworksEnabled(): boolean;
+	getSettingsRevision(): number;
+	getSessionSettingsIdentity(session: TSession): unknown;
+	getSessionSettingsRevision(session: TSession): number;
+	goalStatusInFooter(session: TSession): boolean;
+	activeAccount(session: TSession, provider: string): StatusAccountIdentity | undefined;
+	canFetchUsageReports(session: TSession): boolean;
+	fetchUsageReports(session: TSession, signal: AbortSignal): Promise<unknown>;
+	resolveActiveRepo(cwd: string): ActiveRepoContext | null;
+	lookupPullRequest(cwd: string): Promise<{ stdout: string; exitCode: number }>;
+	calculateTokensPerSecond(messages: readonly AgentMessage[], isStreaming: boolean): number | null;
+	limitMatchesActiveAccount(report: UsageReport, limit: UsageLimit, identity: StatusAccountIdentity): boolean;
+	computeCompactionBoundaries(session: TSession, contextWindow: number, model?: Model): CompactionBoundaries | null;
+}
+
+export interface FooterHost {
+	gitEnabled(): boolean;
+}

package/src/status-line/index.ts

@@ -0,0 +1,6 @@
+export * from "./component";
+export * from "./metrics";
+export * from "./presets";
+export * from "./segments";
+export * from "./separators";
+export * from "./types";

package/src/status-line/loop.ts

@@ -0,0 +1,28 @@
+import { truncateToWidth } from "../render/render-utils";
+import { sanitizeStatusText } from "../chrome/shared";
+
+/** A `/loop --while` / `/loop --until` continue-condition. */
+export interface LoopConditionConfig {
+	/** Shell command line, run through the user's configured shell. */
+	command: string;
+	/** `--until`: continue while the command *fails*. `--while`: while it succeeds. */
+	until: boolean;
+}
+
+export type LoopLimitRuntime =
+	| {
+			kind: "iterations";
+			initial: number;
+			remaining: number;
+	  }
+	| {
+			kind: "duration";
+			durationMs: number;
+			deadlineMs: number;
+	  };
+
+/** Compact status-line form: `until: bun test`. */
+export function summarizeLoopCondition(condition: LoopConditionConfig, maxWidth: number): string {
+	const label = condition.until ? "until" : "while";
+	return `${label}: ${truncateToWidth(sanitizeStatusText(condition.command), Math.max(1, maxWidth - label.length - 2))}`;
+}

package/src/status-line/metrics.ts

@@ -0,0 +1,94 @@
+import { formatNumber } from "@oh-my-pi/pi-utils";
+import type { Theme } from "../theme";
+
+/** Inputs whose differences are intentionally preserved between current status segments and the legacy footer. */
+export interface BillingSummaryOptions {
+	readonly cost: number;
+	readonly usingSubscription: boolean;
+	readonly premiumRequests: number;
+	readonly fractionDigits: number;
+	readonly startupPlaceholder?: boolean;
+	readonly pricingPeriod?: "peak" | "off-peak";
+	readonly advisor?: {
+		readonly cost: number;
+		readonly usingSubscription: boolean;
+	};
+}
+
+/** Round premium-request counters without losing legitimate fractional requests. */
+export function normalizePremiumRequests(value: number): number {
+	return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+
+function formatSpend(amount: number, usingSubscription: boolean, fractionDigits: number, uiTheme: Theme): string {
+	const formatted = amount.toFixed(fractionDigits);
+	if (!usingSubscription) return `$${formatted}`;
+	if (uiTheme.getSymbolPreset() === "nerd") {
+		const icon = uiTheme.icon.subscription;
+		return icon ? `${icon} ${formatted}` : `S${formatted}`;
+	}
+	return `S${formatted}`;
+}
+
+function formatSpendPlaceholder(usingSubscription: boolean, uiTheme: Theme): string {
+	if (!usingSubscription) return "$…";
+	if (uiTheme.getSymbolPreset() === "nerd" && uiTheme.icon.subscription) {
+		return `${uiTheme.icon.subscription} …`;
+	}
+	return "S…";
+}
+
+function formatAdvisorSpend(
+	amount: number,
+	usingSubscription: boolean,
+	fractionDigits: number,
+	placeholder: boolean,
+	uiTheme: Theme,
+): string {
+	const spend = placeholder
+		? formatSpendPlaceholder(usingSubscription, uiTheme)
+		: formatSpend(amount, usingSubscription, fractionDigits, uiTheme);
+	const icon = uiTheme.icon.advisor;
+	return icon && icon !== "(adv)" ? `${icon} ${spend}` : `${spend} (adv)`;
+}
+
+/**
+ * Shared billing metric presentation. Callers select precision explicitly so
+ * the legacy footer keeps three decimals while current status segments keep two.
+ */
+export function formatBillingSummary(options: BillingSummaryOptions, uiTheme: Theme): string | undefined {
+	const premiumRequests = normalizePremiumRequests(options.premiumRequests);
+	const advisorCost = options.advisor?.cost ?? 0;
+	if (!options.cost && !advisorCost && !options.usingSubscription && !premiumRequests && !options.pricingPeriod) {
+		return undefined;
+	}
+
+	const placeholder = options.startupPlaceholder === true;
+	const parts: string[] = [];
+	if (options.cost || options.pricingPeriod) {
+		parts.push(
+			placeholder
+				? formatSpendPlaceholder(options.usingSubscription, uiTheme)
+				: formatSpend(options.cost, options.usingSubscription, options.fractionDigits, uiTheme),
+		);
+	} else if (options.usingSubscription) {
+		parts.push(
+			uiTheme.getSymbolPreset() === "nerd" && uiTheme.icon.subscription ? uiTheme.icon.subscription : "(sub)",
+		);
+	}
+	if (options.pricingPeriod) parts.push(options.pricingPeriod === "peak" ? "↑" : "↓");
+	if (premiumRequests) parts.push(`★ ${placeholder ? "…" : formatNumber(premiumRequests)}`);
+	if (advisorCost && options.advisor) {
+		const prefix = parts.length > 0 ? "+ " : "";
+		parts.push(
+			`${prefix}${formatAdvisorSpend(
+				advisorCost,
+				options.advisor.usingSubscription,
+				options.fractionDigits,
+				placeholder,
+				uiTheme,
+			)}`,
+		);
+	}
+	return parts.length > 0 ? parts.join(" ") : undefined;
+}