rinco-pi-hud 1.0.0

package/extensions/hud/telemetry/format.ts

@@ -0,0 +1,434 @@
+import { homedir, hostname, userInfo } from "node:os";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type {
+	ColorSource,
+	ColorSpec,
+	ContextStyle,
+	ContextThresholds,
+	GitBranchMaxLength,
+	PathDisplayMode,
+} from "../config/config.js";
+import type { GitCommitInfo, GitMetricsInfo } from "../segments/git.js";
+import type { IconMode } from "../ui/icons.js";
+import { resolveOsIcon, resolvePackageIcon, resolveRuntimeSymbol } from "../ui/icons.js";
+import type { PackageVersionResult } from "../segments/package-version.js";
+import type { RuntimeInfo } from "../segments/runtime.js";
+import { renderStyleForSource } from "../ui/style.js";
+
+/**
+ * Starship `git_commit` style — render a short hash, optionally with an
+ * exact-match tag. See https://starship.rs/config/#git-commit
+ *
+ * Visibility is decided by the caller; this helper only formats the data.
+ * `hashLength` is clamped to [4, 40] upstream.
+ */
+export function formatGitCommitSegment(
+	theme: Pick<Theme, "fg">,
+	commit: GitCommitInfo | undefined,
+	config: { hashLength: number; onlyDetached: boolean; showTag: boolean },
+	colorSource: ColorSource,
+	style: ColorSpec,
+): string {
+	if (!commit?.oid) return "";
+	// Starship's only_detached hides the whole module when attached.
+	if (config.onlyDetached && !commit.detached) return "";
+	const hash = commit.oid.slice(0, config.hashLength);
+	const tag = config.showTag && commit.tag ? commit.tag : "";
+	if (!hash && !tag) return "";
+	const label = [hash, tag].filter(Boolean).join(" ");
+	return renderStyleForSource(theme, colorSource, style, label);
+}
+
+/**
+ * Starship `git_metrics` style — render `+added −deleted` line counts.
+ * See https://starship.rs/config/#git-metrics
+ *
+ * When `onlyNonzero` is true, each zero component is omitted independently
+ * and the whole segment hides at 0/0.
+ */
+export function formatGitMetricsSegment(
+	theme: Pick<Theme, "fg">,
+	metrics: GitMetricsInfo | null | undefined,
+	config: { onlyNonzero: boolean },
+	colorSource: ColorSource,
+	addedStyle: ColorSpec,
+	deletedStyle: ColorSpec,
+): string {
+	if (!metrics) return "";
+	const showAdded = !config.onlyNonzero || metrics.added > 0;
+	const showDeleted = !config.onlyNonzero || metrics.deleted > 0;
+	if (!showAdded && !showDeleted) return "";
+	const parts: string[] = [];
+	if (showAdded) {
+		parts.push(renderStyleForSource(theme, colorSource, addedStyle, `+ ${metrics.added}`));
+	}
+	if (showDeleted) {
+		parts.push(renderStyleForSource(theme, colorSource, deletedStyle, `− ${metrics.deleted}`));
+	}
+	return parts.join(" ");
+}
+
+export type UsageTotals = {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	latestCacheHitRate?: number;
+	cost: number;
+};
+
+export type ContextColorTier = "normal" | "warning" | "error";
+
+type SessionEntry = {
+	type?: string;
+	id?: string | number;
+	timestamp?: string | number;
+	message?: {
+		role?: string;
+		usage?: AssistantMessage["usage"];
+	};
+};
+
+type UsageCacheEntry = {
+	key: string;
+	totals: UsageTotals;
+};
+
+let usageTotalsCache: UsageCacheEntry | undefined;
+let usageTotalsComputeCount = 0;
+
+export function formatCount(value: number): string {
+	if (value < 1000) return value.toString();
+	if (value < 10_000) return `${(value / 1000).toFixed(1)}k`;
+	if (value < 1_000_000) return `${Math.round(value / 1000)}k`;
+	if (value < 10_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
+	return `${Math.round(value / 1_000_000)}M`;
+}
+
+export function formatProviderLabel(provider: string | undefined): string {
+	if (!provider) return "Unknown";
+
+	const known: Record<string, string> = {
+		anthropic: "Anthropic",
+		gemini: "Google",
+		google: "Google",
+		ollama: "Ollama",
+		openai: "OpenAI",
+		"openai-codex": "OpenAI",
+	};
+
+	return (
+		known[provider] ?? provider.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase())
+	);
+}
+
+function calculateCacheHitRate(
+	input: number,
+	cacheRead: number,
+	cacheWrite: number,
+): number | undefined {
+	const promptTokens = input + cacheRead + cacheWrite;
+	return promptTokens > 0 ? (cacheRead / promptTokens) * 100 : undefined;
+}
+
+function entryIdentity(entry: SessionEntry | undefined): string {
+	if (!entry) return "";
+	const usage = entry.message?.usage;
+	const usageKey = usage
+		? `${usage.input ?? 0}:${usage.output ?? 0}:${usage.cacheRead ?? 0}:${usage.cacheWrite ?? 0}:${usage.cost?.total ?? 0}`
+		: "";
+	return `${entry.id ?? ""}|${entry.timestamp ?? ""}|${entry.type ?? ""}|${entry.message?.role ?? ""}|${usageKey}`;
+}
+
+function buildUsageFingerprint(entries: readonly SessionEntry[]): string {
+	const first = entries[0];
+	const last = entries[entries.length - 1];
+	return `${entries.length}\0${entryIdentity(first)}\0${entryIdentity(last)}`;
+}
+
+function computeUsageTotals(entries: readonly SessionEntry[]): UsageTotals {
+	usageTotalsComputeCount += 1;
+	let input = 0;
+	let output = 0;
+	let cacheRead = 0;
+	let cacheWrite = 0;
+	let latestCacheHitRate: number | undefined;
+	let cost = 0;
+
+	for (const entry of entries) {
+		if (entry.type !== "message" || entry.message?.role !== "assistant") continue;
+		const usage = entry.message.usage;
+		const entryInput = usage?.input ?? 0;
+		const entryCacheRead = usage?.cacheRead ?? 0;
+		const entryCacheWrite = usage?.cacheWrite ?? 0;
+
+		input += entryInput;
+		output += usage?.output ?? 0;
+		cacheRead += entryCacheRead;
+		cacheWrite += entryCacheWrite;
+		cost += usage?.cost?.total ?? 0;
+		latestCacheHitRate = calculateCacheHitRate(entryInput, entryCacheRead, entryCacheWrite);
+	}
+
+	return Object.freeze({ input, output, cacheRead, cacheWrite, latestCacheHitRate, cost });
+}
+
+export function invalidateUsageTotalsCache(): void {
+	usageTotalsCache = undefined;
+}
+
+/** Test helper: number of full usage scans performed since process start / last reset. */
+export function __usageTotalsComputeCount(): number {
+	return usageTotalsComputeCount;
+}
+
+/** Test helper: reset memoization counters/cache. */
+export function __resetUsageTotalsCacheForTests(): void {
+	usageTotalsCache = undefined;
+	usageTotalsComputeCount = 0;
+}
+
+export function getUsageTotals(ctx: ExtensionContext): UsageTotals {
+	const sessionManager = ctx.sessionManager as {
+		getEntries?: () => SessionEntry[];
+		getBranch: () => SessionEntry[];
+	};
+	const entries = sessionManager.getEntries?.() ?? sessionManager.getBranch();
+	const key = buildUsageFingerprint(entries);
+	if (usageTotalsCache?.key === key) return usageTotalsCache.totals;
+
+	const totals = computeUsageTotals(entries);
+	usageTotalsCache = { key, totals };
+	return totals;
+}
+
+export function buildTokenLabel(totals: UsageTotals, cacheHitIcon = "󰆼"): string {
+	const parts: string[] = [];
+	if (totals.input) parts.push(`↑ ${formatCount(totals.input)}`);
+	if (totals.output) parts.push(`↓ ${formatCount(totals.output)}`);
+
+	const hasCacheTokens = totals.cacheRead > 0 || totals.cacheWrite > 0;
+	if (hasCacheTokens && totals.latestCacheHitRate !== undefined) {
+		const cacheHitRate = `${totals.latestCacheHitRate.toFixed(1)}%`;
+		parts.push(cacheHitIcon ? `${cacheHitIcon} ${cacheHitRate}` : cacheHitRate);
+	}
+	return parts.length > 0 ? parts.join(" ") : "↑ 0 ↓ 0";
+}
+
+export function buildCostLabel(totals: UsageTotals): string {
+	return `$ ${totals.cost.toFixed(3)}`;
+}
+
+export function buildSessionDurationLabel(startEpoch: number): string {
+	const totalSeconds = Math.max(0, Math.floor((Date.now() - startEpoch) / 1000));
+	const hours = Math.floor(totalSeconds / 3600);
+	const minutes = Math.floor((totalSeconds % 3600) / 60);
+	const seconds = totalSeconds % 60;
+	if (hours > 0) return `${hours}h ${minutes}m`;
+	if (minutes > 0) return `${minutes}m ${seconds}s`;
+	return `${seconds}s`;
+}
+
+export function contextColorTier(
+	percent: number | null | undefined,
+	thresholds: ContextThresholds = { warning: 70, error: 90 },
+): ContextColorTier {
+	if (percent === null || percent === undefined || !Number.isFinite(percent)) return "normal";
+	if (percent >= thresholds.error) return "error";
+	if (percent >= thresholds.warning) return "warning";
+	return "normal";
+}
+
+export function buildContextGauge(percent: number, width = 10, ascii = false): string {
+	const clamped = Math.max(0, Math.min(100, percent));
+	const filled = Math.round((clamped / 100) * width);
+	const on = ascii ? "#" : "█";
+	const off = ascii ? "-" : "░";
+	return `${on.repeat(filled)}${off.repeat(Math.max(0, width - filled))}`;
+}
+
+export function formatContextPercentLabel(
+	percent: number | null | undefined,
+	contextWindow: number | undefined,
+): string {
+	if (!contextWindow || contextWindow <= 0) return "--";
+	const percentLabel =
+		percent === null || percent === undefined
+			? "?"
+			: `${Math.max(0, Math.min(999, Math.round(percent)))}%`;
+	return `${percentLabel}/${formatCount(contextWindow)}`;
+}
+
+export function buildContextDisplayLabel(options: {
+	percent: number | null | undefined;
+	contextWindow: number | undefined;
+	style?: ContextStyle;
+	asciiGauge?: boolean;
+}): string {
+	const { percent, contextWindow, style = "text", asciiGauge = false } = options;
+	if (!contextWindow || contextWindow <= 0) return "--";
+
+	const text = formatContextPercentLabel(percent, contextWindow);
+	const numericPercent =
+		percent === null || percent === undefined || !Number.isFinite(percent)
+			? 0
+			: Math.max(0, Math.min(100, percent));
+	const gauge = buildContextGauge(numericPercent, 10, asciiGauge);
+
+	if (style === "gauge") return `[${gauge}]`;
+	if (style === "text+gauge") return `[${gauge}] ${text}`;
+	return text;
+}
+
+export function buildContextLabel(ctx: ExtensionContext): string {
+	const usage = ctx.getContextUsage();
+	const contextWindow = ctx.model?.contextWindow ?? usage?.contextWindow;
+	return formatContextPercentLabel(usage?.percent, contextWindow);
+}
+
+export function formatRuntimeSegment(
+	theme: Pick<Theme, "fg">,
+	runtime: RuntimeInfo | undefined,
+	prefixStyle: ColorSpec,
+	colorSource: ColorSource,
+	mode: IconMode = "auto",
+): string {
+	if (!runtime) return "";
+	const symbol = resolveRuntimeSymbol(runtime.name, runtime.symbol, mode);
+	const label = runtime.version ? `${symbol} ${runtime.version}` : symbol;
+	return `${renderStyleForSource(theme, colorSource, prefixStyle, "via")} ${renderStyleForSource(theme, colorSource, runtime.style, label)}`;
+}
+
+/**
+ * Render the package-version segment in Starship `is <glyph> <version>` shape.
+ *
+ * Distinct from the runtime segment: this surfaces the project's own
+ * manifest version (e.g. `package.json#version`), not the installed
+ * toolchain version. Glyph comes from the Starship Nerd Font preset
+ * (https://starship.rs/presets/nerd-font); default color `208` matches
+ * the Starship `package` module default
+ * (https://starship.rs/config/#package-version).
+ */
+export function formatPackageVersionSegment(
+	theme: Pick<Theme, "fg">,
+	pkg: PackageVersionResult | undefined,
+	colorSource: ColorSource,
+	mode: IconMode = "auto",
+	configuredIcon: string = "",
+	versionStyle: ColorSpec = "208",
+): string {
+	if (!pkg) return "";
+	const icon = resolvePackageIcon(configuredIcon, mode);
+	const label = `${icon} ${pkg.version}`;
+	return `${renderStyleForSource(theme, colorSource, "", "is")} ${renderStyleForSource(theme, colorSource, versionStyle, label)}`;
+}
+
+export type FormatCwdOptions = {
+	mode?: PathDisplayMode;
+	/** Trailing directory components to keep in full mode. 0 = unlimited. */
+	depth?: number;
+	home?: string;
+};
+
+function normalizeDisplayPath(cwd: string): string {
+	const withSlashes = cwd.replace(/\\/g, "/");
+	if (withSlashes === "/" || /^\/+$/.test(withSlashes)) return "/";
+	const stripped = withSlashes.replace(/\/+$/, "");
+	return stripped === "" ? withSlashes : stripped;
+}
+
+function toHomePath(path: string, home: string): string {
+	if (!home) return path;
+	const homeNorm = home.replace(/\\/g, "/").replace(/\/+$/, "");
+	if (!homeNorm) return path;
+	if (path === homeNorm) return "~";
+	if (path.startsWith(`${homeNorm}/`)) return `~${path.slice(homeNorm.length)}`;
+	return path;
+}
+
+/** Starship-style: keep last `depth` components; prefix with `…/` when parents were dropped. */
+function applyPathDepth(path: string, depth: number): string {
+	if (!Number.isFinite(depth) || depth <= 0) return path;
+	const limit = Math.floor(depth);
+	if (path === "~" || path === "/") return path;
+
+	let components: string[];
+	if (path.startsWith("~/")) {
+		components = path.slice(2).split("/").filter(Boolean);
+	} else if (/^[A-Za-z]:\//.test(path)) {
+		components = path.slice(3).split("/").filter(Boolean);
+	} else if (path.startsWith("/")) {
+		components = path.slice(1).split("/").filter(Boolean);
+	} else {
+		components = path.split("/").filter(Boolean);
+	}
+
+	if (components.length <= limit) return path;
+	return `…/${components.slice(-limit).join("/")}`;
+}
+
+export function formatCwdLabel(cwd: string, cwdIcon: string, options?: FormatCwdOptions): string {
+	const mode = options?.mode ?? "basename";
+	const normalized = normalizeDisplayPath(cwd);
+	let pathText: string;
+	if (mode === "full") {
+		const home =
+			options?.home ??
+			(() => {
+				try {
+					return homedir();
+				} catch {
+					return "";
+				}
+			})();
+		pathText = applyPathDepth(toHomePath(normalized, home), options?.depth ?? 0);
+	} else if (normalized === "/") {
+		pathText = "/";
+	} else {
+		const parts = normalized.split("/").filter(Boolean);
+		pathText = parts[parts.length - 1] ?? cwd;
+	}
+	return cwdIcon ? `${cwdIcon} ${pathText}` : pathText;
+}
+
+function stripAnsi(text: string): string {
+	return text.replace(/\u001B\[[0-9;]*m/g, "");
+}
+
+export function formatGitBranchText(
+	branch: string,
+	maxLength: GitBranchMaxLength = "full",
+): string {
+	if (maxLength === "full" || visibleWidth(branch) <= maxLength) return branch;
+	return stripAnsi(truncateToWidth(branch, maxLength, "…"));
+}
+
+export function formatUsernameHostLabel(icon: string): string {
+	try {
+		const user = userInfo().username;
+		const host = hostname();
+		if (!user || !host) return "";
+		const label = `${user}@${host}`;
+		return icon ? `${icon} ${label}` : label;
+	} catch {
+		return "";
+	}
+}
+
+export function formatTimeLabel(icon: string): string {
+	const now = new Date();
+	const hours = String(now.getHours()).padStart(2, "0");
+	const minutes = String(now.getMinutes()).padStart(2, "0");
+	const label = `${hours}:${minutes}`;
+	return icon ? `${icon} ${label}` : label;
+}
+
+export function formatOsLabel(
+	configuredIcon: string,
+	mode: IconMode = "auto",
+	platform: string = process.platform,
+): string {
+	return resolveOsIcon(configuredIcon, mode, platform);
+}

package/extensions/hud/telemetry/token-switch.ts

@@ -0,0 +1,114 @@
+const TOKEN_SWITCH_PROVIDER_ID = "token-switch";
+const TOKEN_SWITCH_SUBSCRIPTION_URL =
+	"https://neolink.com/backend/v1/dashboard/billing/subscription";
+const TOKEN_SWITCH_USAGE_URL = "https://neolink.com/backend/v1/dashboard/billing/usage";
+const MAX_RESPONSE_BODY_BYTES = 64 * 1024;
+
+export type TokenSwitchModel = { provider: string };
+
+type QueryTokenSwitchBalanceOptions = {
+	apiKey?: string;
+	fetchImpl?: typeof fetch;
+	timeoutMs: number;
+	signal?: AbortSignal;
+};
+
+export function isTokenSwitchModel(
+	model: Pick<TokenSwitchModel, "provider"> | undefined,
+): boolean {
+	return model?.provider === TOKEN_SWITCH_PROVIDER_ID;
+}
+
+export function parseTokenSwitchBalance(
+	subscriptionPayload: unknown,
+	usagePayload: unknown,
+): number {
+	if (
+		!subscriptionPayload ||
+		typeof subscriptionPayload !== "object" ||
+		Array.isArray(subscriptionPayload)
+	) {
+		throw new Error("Token Switch subscription response did not contain hard_limit_usd.");
+	}
+	const hardLimitUsd = (subscriptionPayload as Record<string, unknown>).hard_limit_usd;
+	if (typeof hardLimitUsd !== "number" || !Number.isFinite(hardLimitUsd) || hardLimitUsd < 0) {
+		throw new Error("Token Switch hard_limit_usd was not a non-negative number.");
+	}
+
+	if (!usagePayload || typeof usagePayload !== "object" || Array.isArray(usagePayload)) {
+		throw new Error("Token Switch usage response did not contain total_usage.");
+	}
+	const totalUsage = (usagePayload as Record<string, unknown>).total_usage;
+	if (typeof totalUsage !== "number" || !Number.isFinite(totalUsage) || totalUsage < 0) {
+		throw new Error("Token Switch total_usage was not a non-negative number.");
+	}
+
+	return hardLimitUsd - totalUsage / 100;
+}
+
+export function formatTokenSwitchBalance(balance: number): string {
+	return `token-switch $${balance.toFixed(2)}`;
+}
+
+export async function queryTokenSwitchBalance({
+	apiKey = process.env.TOKEN_SWITCH_API_KEY,
+	fetchImpl = fetch,
+	timeoutMs,
+	signal,
+}: QueryTokenSwitchBalanceOptions): Promise<number> {
+	if (!apiKey?.trim()) {
+		throw new Error("TOKEN_SWITCH_API_KEY is not configured.");
+	}
+
+	const controller = new AbortController();
+	const abortFromExternal = () => controller.abort();
+	if (signal?.aborted) controller.abort();
+	else signal?.addEventListener("abort", abortFromExternal, { once: true });
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+	const fetchPayload = async (url: string, label: string): Promise<unknown> => {
+		const response = await fetchImpl(url, {
+			method: "GET",
+			headers: {
+				Accept: "application/json",
+				Authorization: `Bearer ${apiKey}`,
+			},
+			redirect: "error",
+			signal: controller.signal,
+		});
+		if (!response.ok) {
+			throw new Error(`Token Switch ${label} endpoint returned HTTP ${response.status}.`);
+		}
+
+		const text = await response.text();
+		if (Buffer.byteLength(text, "utf8") > MAX_RESPONSE_BODY_BYTES) {
+			throw new Error(`Token Switch ${label} response exceeded the size limit.`);
+		}
+		try {
+			return JSON.parse(text) as unknown;
+		} catch {
+			throw new Error(`Token Switch ${label} response was not valid JSON.`);
+		}
+	};
+
+	try {
+		const subscriptionPayload = await fetchPayload(
+			TOKEN_SWITCH_SUBSCRIPTION_URL,
+			"subscription",
+		);
+		const usagePayload = await fetchPayload(TOKEN_SWITCH_USAGE_URL, "usage");
+		return parseTokenSwitchBalance(subscriptionPayload, usagePayload);
+	} catch (error) {
+		if (controller.signal.aborted) {
+			throw new Error(
+				signal?.aborted
+					? "Token Switch balance query was cancelled."
+					: `Timed out after ${Math.round(timeoutMs / 1000)}s while fetching Token Switch balance.`,
+			);
+		}
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+		signal?.removeEventListener("abort", abortFromExternal);
+	}
+}