rinco-pi-hud 1.0.0

package/extensions/hud/segments/runtime.ts

@@ -0,0 +1,167 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { runtimeDefinitions, type RuntimeDef } from "./runtime-definitions.js";
+
+export type RuntimeMetadata = {
+	name: string;
+	symbol: string;
+	style: string;
+};
+
+export type RuntimeInfo = Pick<RuntimeMetadata, "name" | "symbol" | "style"> & {
+	version?: string;
+};
+
+export type RuntimeReadResult = { kind: "ok"; runtime?: RuntimeInfo } | { kind: "error" };
+
+type RuntimeCacheEntry = {
+	fingerprint: string;
+	runtime: RuntimeInfo | undefined;
+};
+
+const RUNTIME_CACHE_MAX = 32;
+const runtimeInfoCache = new Map<string, RuntimeCacheEntry>();
+
+export function clearRuntimeInfoCache(): void {
+	runtimeInfoCache.clear();
+}
+
+function topLevelFingerprint(entries: readonly string[]): string {
+	return entries.slice().sort().join("\0");
+}
+
+function cacheRuntimeInfo(
+	cwd: string,
+	fingerprint: string,
+	runtime: RuntimeInfo | undefined,
+): void {
+	// Drop prior fingerprints for the same cwd so stale marker sets do not linger.
+	for (const key of runtimeInfoCache.keys()) {
+		if (key === cwd || key.startsWith(`${cwd}\0`)) runtimeInfoCache.delete(key);
+	}
+	const key = `${cwd}\0${fingerprint}`;
+	runtimeInfoCache.set(key, { fingerprint, runtime });
+	while (runtimeInfoCache.size > RUNTIME_CACHE_MAX) {
+		const oldest = runtimeInfoCache.keys().next().value;
+		if (oldest === undefined) break;
+		runtimeInfoCache.delete(oldest);
+	}
+}
+
+export type RuntimeEnvironment = Record<string, string | undefined>;
+
+export type DetectionSpec = {
+	extensions?: readonly string[];
+	files?: readonly string[];
+	folders?: readonly string[];
+	env?: (env: RuntimeEnvironment) => boolean;
+	excludedFiles?: readonly string[];
+};
+
+// --- Detection utilities ---
+
+function hasAnyFile(cwd: string, names: readonly string[]): boolean {
+	return names.some((name) => existsSync(join(cwd, name)));
+}
+
+function hasAnyFolder(cwd: string, names: readonly string[]): boolean {
+	return names.some((name) => {
+		try {
+			return statSync(join(cwd, name)).isDirectory();
+		} catch {
+			return false;
+		}
+	});
+}
+
+function entryExtensions(entry: string): string[] {
+	const baseName = entry.split(/[\\/]/).pop() ?? entry;
+	if (!baseName || baseName.startsWith(".")) return [];
+
+	const firstDot = baseName.indexOf(".");
+	if (firstDot === -1) return [];
+
+	const extensions = [baseName.slice(firstDot + 1)];
+	const lastDot = baseName.lastIndexOf(".");
+	if (lastDot !== firstDot) extensions.push(baseName.slice(lastDot + 1));
+	return extensions;
+}
+
+function hasAnyExtension(entries: readonly string[], extensions: readonly string[]): boolean {
+	const extensionSet = new Set(extensions);
+	return entries.some((entry) =>
+		entryExtensions(entry).some((extension) => extensionSet.has(extension)),
+	);
+}
+
+function matchesDetection(
+	cwd: string,
+	entries: string[],
+	spec: DetectionSpec,
+	env: RuntimeEnvironment,
+): boolean {
+	if (spec.excludedFiles && hasAnyFile(cwd, spec.excludedFiles)) return false;
+	return Boolean(
+		(spec.files && hasAnyFile(cwd, spec.files)) ||
+			(spec.folders && hasAnyFolder(cwd, spec.folders)) ||
+			(spec.extensions && hasAnyExtension(entries, spec.extensions)) ||
+			spec.env?.(env),
+	);
+}
+
+// Definitions are pre-sorted by priority in runtime-definitions.ts.
+const sortedRuntimes = runtimeDefinitions;
+
+export const runtimeMetadata: RuntimeMetadata[] = runtimeDefinitions.map(
+	({ name, symbol, style }) => ({
+		name,
+		symbol,
+		style,
+	}),
+);
+
+export function detectRuntime(
+	cwd: string,
+	entries: string[],
+	env: RuntimeEnvironment = process.env,
+): RuntimeDef | undefined {
+	for (const runtime of sortedRuntimes) {
+		if (matchesDetection(cwd, entries, runtime.detect, env)) return runtime;
+	}
+	return undefined;
+}
+
+export async function readRuntimeInfo(cwd: string): Promise<RuntimeReadResult> {
+	let entries: string[];
+	try {
+		entries = readdirSync(cwd);
+	} catch {
+		// readdir failure is treated as a transient error so last-good can be kept.
+		return { kind: "error" };
+	}
+
+	const fingerprint = topLevelFingerprint(entries);
+	const cacheKey = `${cwd}\0${fingerprint}`;
+	const cached = runtimeInfoCache.get(cacheKey);
+	if (cached && cached.fingerprint === fingerprint) {
+		return { kind: "ok", runtime: cached.runtime };
+	}
+
+	try {
+		const runtime = detectRuntime(cwd, entries);
+		if (!runtime) {
+			cacheRuntimeInfo(cwd, fingerprint, undefined);
+			return { kind: "ok", runtime: undefined };
+		}
+		const info: RuntimeInfo = {
+			name: runtime.name,
+			symbol: runtime.symbol,
+			style: runtime.style,
+			version: await runtime.version(cwd),
+		};
+		cacheRuntimeInfo(cwd, fingerprint, info);
+		return { kind: "ok", runtime: info };
+	} catch {
+		return { kind: "error" };
+	}
+}

package/extensions/hud/segments/skill-activity.ts

@@ -0,0 +1,152 @@
+import { isAbsolute, normalize, resolve } from "node:path";
+
+export interface SkillReference {
+	name: string;
+	filePath: string;
+}
+
+export interface SkillCounts {
+	total: number;
+	active: number;
+}
+
+type RecordLike = Record<string, unknown>;
+
+function isRecord(value: unknown): value is RecordLike {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Normalize a skill path to a canonical absolute form for equality checks.
+ *
+ * Scope note: the result is only ever used as a `Map`/`Set` key to compare
+ * "available skill" paths against "activated skill" paths — it is never
+ * passed to `fs`/`child_process`. It intentionally does not verify the
+ * normalized path stays under `cwd`; if a future change starts using this
+ * path for file I/O, add that containment check first.
+ */
+function normalizeSkillPath(path: string, cwd: string): string | undefined {
+	const withoutAt = path.startsWith("@") ? path.slice(1) : path;
+	if (!withoutAt || withoutAt.includes("\0")) return undefined;
+	return normalize(isAbsolute(withoutAt) ? withoutAt : resolve(cwd, withoutAt));
+}
+
+function messageText(message: RecordLike): string {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter((item): item is RecordLike => isRecord(item) && item.type === "text")
+		.map((item) => (typeof item.text === "string" ? item.text : ""))
+		.join("\n");
+}
+
+function toolCalls(message: RecordLike): RecordLike[] {
+	if (!Array.isArray(message.content)) return [];
+	return message.content.filter(
+		(item): item is RecordLike => isRecord(item) && item.type === "toolCall",
+	);
+}
+
+function readPathFromToolCall(toolCall: RecordLike): string | undefined {
+	if (toolCall.name !== "read" || !isRecord(toolCall.arguments)) return undefined;
+	const path = toolCall.arguments.path;
+	return typeof path === "string" ? path : undefined;
+}
+
+const SKILL_BLOCK_PATTERN = /<skill\s+name="[^"\r\n]{1,128}"\s+location="([^"\r\n]{1,4096})">/g;
+
+export class SkillActivityTracker {
+	private availableByName = new Map<string, string>();
+	private activatedPaths = new Set<string>();
+	private synced = false;
+
+	reset(): void {
+		this.availableByName.clear();
+		this.activatedPaths.clear();
+		this.synced = false;
+	}
+
+	syncAvailable(skills: readonly SkillReference[], cwd: string): boolean {
+		const before = this.counts();
+		const next = new Map<string, string>();
+		for (const skill of skills) {
+			if (!skill.name || next.has(skill.name)) continue;
+			const path = normalizeSkillPath(skill.filePath, cwd);
+			if (path) next.set(skill.name, path);
+		}
+		this.availableByName = next;
+		this.synced = true;
+		return !sameCounts(before, this.counts());
+	}
+
+	activateFromPrompt(prompt: string, cwd: string): boolean {
+		const before = this.counts();
+		SKILL_BLOCK_PATTERN.lastIndex = 0;
+		let match = SKILL_BLOCK_PATTERN.exec(prompt);
+		while (match) {
+			const path = match[1] ? normalizeSkillPath(match[1], cwd) : undefined;
+			if (path) this.activatedPaths.add(path);
+			match = SKILL_BLOCK_PATTERN.exec(prompt);
+		}
+		return !sameCounts(before, this.counts());
+	}
+
+	activateFromRead(path: string, cwd: string): boolean {
+		const before = this.counts();
+		const normalized = normalizeSkillPath(path, cwd);
+		if (normalized) this.activatedPaths.add(normalized);
+		return !sameCounts(before, this.counts());
+	}
+
+	restoreFromEntries(entries: readonly unknown[], cwd: string): boolean {
+		const before = this.counts();
+		this.activatedPaths.clear();
+		const pendingReads = new Map<string, string>();
+
+		for (const entry of entries) {
+			if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message)) continue;
+			const message = entry.message;
+			if (message.role === "user") {
+				this.activateFromPrompt(messageText(message), cwd);
+				continue;
+			}
+			if (message.role === "assistant") {
+				for (const toolCall of toolCalls(message)) {
+					const id = typeof toolCall.id === "string" ? toolCall.id : undefined;
+					const path = readPathFromToolCall(toolCall);
+					if (id && path) pendingReads.set(id, path);
+				}
+				continue;
+			}
+			if (message.role !== "toolResult" || message.toolName !== "read" || message.isError === true) {
+				continue;
+			}
+			const id = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
+			const path = id ? pendingReads.get(id) : undefined;
+			if (path) this.activateFromRead(path, cwd);
+		}
+
+		return !sameCounts(before, this.counts());
+	}
+
+	counts(): SkillCounts | undefined {
+		if (!this.synced) return undefined;
+		const activeNames = new Set<string>();
+		for (const [name, path] of this.availableByName) {
+			if (this.activatedPaths.has(path)) activeNames.add(name);
+		}
+		return { total: this.availableByName.size, active: activeNames.size };
+	}
+}
+
+function sameCounts(left: SkillCounts | undefined, right: SkillCounts | undefined): boolean {
+	return left?.total === right?.total && left?.active === right?.active;
+}
+
+export function formatSkillCounts(counts: SkillCounts): string {
+	if (counts.total <= 0) return "";
+	const total = Math.max(0, Math.trunc(counts.total));
+	const active = Math.min(total, Math.max(0, Math.trunc(counts.active)));
+	return `★ ${active}/${total}`;
+}

package/extensions/hud/session/context.ts

@@ -0,0 +1,19 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Pi builds a fresh ctx object for every extension event, so comparing a ctx by
+ * identity against the one captured at `session_start` drops every later update
+ * (model switches, tree navigation, async usage refreshes).
+ *
+ * A ctx belongs to the live session as long as it is not stale: stale contexts
+ * throw on property access after a session replacement or reload.
+ */
+export function isLiveExtensionContext(ctx: ExtensionContext | undefined): boolean {
+	if (!ctx) return false;
+	try {
+		void ctx.hasUI;
+		return true;
+	} catch {
+		return false;
+	}
+}

package/extensions/hud/session/lifecycle.ts

@@ -0,0 +1,60 @@
+export class SessionLifecycle {
+	private generation = 0;
+	private active = false;
+	private readonly timeouts = new Set<ReturnType<typeof setTimeout>>();
+
+	start(): number {
+		this.cancelTimeouts();
+		this.generation += 1;
+		this.active = true;
+		return this.generation;
+	}
+
+	currentGeneration(): number {
+		return this.generation;
+	}
+
+	isCurrent(generation = this.generation): boolean {
+		return this.active && generation === this.generation;
+	}
+
+	defer(callback: () => void, delayMs = 0): () => void {
+		if (!this.active) return () => {};
+		const generation = this.generation;
+		let canceled = false;
+		const timeout = setTimeout(() => {
+			this.timeouts.delete(timeout);
+			if (!canceled && this.isCurrent(generation)) callback();
+		}, delayMs);
+		this.timeouts.add(timeout);
+		return () => {
+			if (canceled) return;
+			canceled = true;
+			clearTimeout(timeout);
+			this.timeouts.delete(timeout);
+		};
+	}
+
+	queueMicrotask(callback: () => void): () => void {
+		let canceled = !this.active;
+		const generation = this.generation;
+		queueMicrotask(() => {
+			if (!canceled && this.isCurrent(generation)) callback();
+		});
+		return () => {
+			canceled = true;
+		};
+	}
+
+	shutdown(): void {
+		if (!this.active && this.timeouts.size === 0) return;
+		this.active = false;
+		this.generation += 1;
+		this.cancelTimeouts();
+	}
+
+	private cancelTimeouts(): void {
+		for (const timeout of this.timeouts) clearTimeout(timeout);
+		this.timeouts.clear();
+	}
+}

package/extensions/hud/session/live-context.ts

@@ -0,0 +1,75 @@
+import type { AssistantMessage, Usage } from "@earendil-works/pi-ai";
+import type { SessionLifecycle } from "./lifecycle.js";
+
+export type LiveContextOverride = {
+	tokens: number;
+};
+
+function usageComponent(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+export function calculateLiveContextTokens(usage: Usage | undefined): number | undefined {
+	if (!usage) return undefined;
+	const totalTokens = usageComponent(usage.totalTokens);
+	if (totalTokens > 0) return totalTokens;
+	const calculated =
+		usageComponent(usage.input) +
+		usageComponent(usage.output) +
+		usageComponent(usage.cacheRead) +
+		usageComponent(usage.cacheWrite);
+	return calculated > 0 ? calculated : undefined;
+}
+
+export function liveContextFromMessage(message: unknown): LiveContextOverride | undefined {
+	if (!message || typeof message !== "object") return undefined;
+	const assistant = message as Partial<AssistantMessage>;
+	if (assistant.role !== "assistant") return undefined;
+	if (assistant.stopReason === "error" || assistant.stopReason === "aborted") return undefined;
+	const tokens = calculateLiveContextTokens(assistant.usage);
+	return tokens === undefined ? undefined : { tokens };
+}
+
+export class LiveContextController {
+	private readonly lifecycle: SessionLifecycle;
+	private readonly requestRender: () => void;
+	private override: LiveContextOverride | undefined;
+	private cancelScheduledRender: (() => void) | undefined;
+	private scheduledGeneration: number | undefined;
+
+	constructor(lifecycle: SessionLifecycle, requestRender: () => void) {
+		this.lifecycle = lifecycle;
+		this.requestRender = requestRender;
+	}
+
+	get(): LiveContextOverride | undefined {
+		return this.override;
+	}
+
+	update(message: unknown): boolean {
+		const next = liveContextFromMessage(message);
+		if (!next || !this.lifecycle.isCurrent()) return false;
+		this.override = next;
+		const generation = this.lifecycle.currentGeneration();
+		if (this.cancelScheduledRender && this.scheduledGeneration !== generation) {
+			this.cancelScheduledRender = undefined;
+			this.scheduledGeneration = undefined;
+		}
+		if (!this.cancelScheduledRender) {
+			this.scheduledGeneration = generation;
+			this.cancelScheduledRender = this.lifecycle.defer(() => {
+				this.cancelScheduledRender = undefined;
+				this.scheduledGeneration = undefined;
+				if (this.override) this.requestRender();
+			}, 250);
+		}
+		return true;
+	}
+
+	clear(): void {
+		this.override = undefined;
+		this.cancelScheduledRender?.();
+		this.cancelScheduledRender = undefined;
+		this.scheduledGeneration = undefined;
+	}
+}

package/extensions/hud/state/index.ts

@@ -0,0 +1,67 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ConfigCounts } from "../config/config-counts.js";
+import {
+	buildContextLabel,
+	buildCostLabel,
+	buildTokenLabel,
+	formatProviderLabel,
+	getUsageTotals,
+	type UsageTotals,
+} from "../telemetry/format.js";
+import type { GitStatusSummary } from "../segments/git.js";
+import type { PackageVersionResult } from "../segments/package-version.js";
+import type { RuntimeInfo } from "../segments/runtime.js";
+import type { SkillCounts } from "../segments/skill-activity.js";
+import { createTelemetryState, type TelemetryState } from "./telemetry.js";
+
+export type FooterState = GitStatusSummary & {
+	modelLabel: string;
+	providerLabel: string;
+	contextLabel: string;
+	tokenLabel: string;
+	costLabel: string;
+	usageTotals: UsageTotals;
+	telemetry: TelemetryState;
+	configCounts: ConfigCounts;
+	skillCounts?: SkillCounts;
+	codexUsageStatus?: string;
+	runtime?: RuntimeInfo;
+	packageVersion?: PackageVersionResult;
+	sessionStartEpoch?: number;
+};
+
+export function createInitialState(gitDefaults: GitStatusSummary): FooterState {
+	return {
+		modelLabel: "no-model",
+		providerLabel: "Unknown",
+		contextLabel: "--",
+		tokenLabel: "↑ 0 ↓ 0",
+		costLabel: "$ 0.000",
+		usageTotals: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
+		telemetry: createTelemetryState(),
+		configCounts: {
+			instructionFiles: { agentsMd: 0, claudeMd: 0, total: 0 },
+			packages: 0,
+		},
+		skillCounts: undefined,
+		codexUsageStatus: undefined,
+		runtime: undefined,
+		packageVersion: undefined,
+		sessionStartEpoch: Date.now(),
+		...gitDefaults,
+	};
+}
+
+export function syncState(state: FooterState, ctx: ExtensionContext, cacheHitIcon: string): void {
+	const totals = getUsageTotals(ctx);
+	state.modelLabel = ctx.model?.id ?? "no-model";
+	state.providerLabel = formatProviderLabel(ctx.model?.provider);
+	state.usageTotals = totals;
+	state.telemetry = {
+		...state.telemetry,
+		modelSupportsReasoning: Boolean(ctx.model?.reasoning),
+	};
+	state.contextLabel = buildContextLabel(ctx);
+	state.tokenLabel = buildTokenLabel(totals, cacheHitIcon);
+	state.costLabel = buildCostLabel(totals);
+}

package/extensions/hud/state/project-refresh.ts

@@ -0,0 +1,104 @@
+export type StopProjectRefreshInterval = () => void;
+
+export type ScheduleProjectRefreshOptions = {
+	force?: boolean;
+};
+
+export type ProjectRefreshScheduler<T> = {
+	schedule: (target: T, options?: ScheduleProjectRefreshOptions) => void;
+	stop: () => void;
+};
+
+export const PROJECT_REFRESH_THROTTLE_MS = 5_000;
+
+export function startProjectRefreshInterval(
+	intervalMs: number,
+	refresh: () => void,
+): StopProjectRefreshInterval {
+	if (intervalMs <= 0) return () => {};
+
+	const timer = setInterval(refresh, intervalMs);
+	timer.unref?.();
+
+	return () => clearInterval(timer);
+}
+
+export function createProjectRefreshScheduler<T>(
+	refresh: (target: T) => Promise<void>,
+	afterRefresh: () => void,
+	throttleMs = PROJECT_REFRESH_THROTTLE_MS,
+): ProjectRefreshScheduler<T> {
+	let refreshInFlight = false;
+	let refreshPending = false;
+	let pendingTarget: T | undefined;
+	let delayedRefresh: ReturnType<typeof setTimeout> | undefined;
+	let lastRefreshStartedAt: number | undefined;
+	let generation = 0;
+
+	const clearDelayedRefresh = () => {
+		if (!delayedRefresh) return;
+		clearTimeout(delayedRefresh);
+		delayedRefresh = undefined;
+	};
+
+	const runRefresh = (target: T) => {
+		clearDelayedRefresh();
+		if (refreshInFlight) {
+			refreshPending = true;
+			pendingTarget = target;
+			return;
+		}
+
+		const currentGeneration = generation;
+		refreshInFlight = true;
+		lastRefreshStartedAt = Date.now();
+		void refresh(target)
+			.catch(() => undefined)
+			.finally(() => {
+				if (currentGeneration !== generation) return;
+				refreshInFlight = false;
+				afterRefresh();
+				if (refreshPending) {
+					refreshPending = false;
+					const nextTarget = pendingTarget ?? target;
+					pendingTarget = undefined;
+					schedule(nextTarget);
+				}
+			});
+	};
+
+	const schedule = (target: T, options: ScheduleProjectRefreshOptions = {}) => {
+		if (options.force || throttleMs <= 0 || lastRefreshStartedAt === undefined) {
+			runRefresh(target);
+			return;
+		}
+
+		const delayMs = Math.max(0, throttleMs - (Date.now() - lastRefreshStartedAt));
+		if (delayMs === 0) {
+			runRefresh(target);
+			return;
+		}
+
+		pendingTarget = target;
+		if (delayedRefresh) return;
+		delayedRefresh = setTimeout(() => {
+			delayedRefresh = undefined;
+			const nextTarget = pendingTarget ?? target;
+			pendingTarget = undefined;
+			runRefresh(nextTarget);
+		}, delayMs);
+		delayedRefresh.unref?.();
+	};
+
+	return {
+		schedule,
+		stop() {
+			generation += 1;
+			clearDelayedRefresh();
+			refreshInFlight = false;
+			refreshPending = false;
+			pendingTarget = undefined;
+			lastRefreshStartedAt = undefined;
+		},
+	};
+}