pi-crew 0.9.26 → 0.9.27

package/src/extension/crew-vibes/figures.ts

@@ -0,0 +1,94 @@
+import type { SpeedConfig } from "./config.ts";
+import { isWebTerminal } from "./font-detect.ts";
+
+/**
+ * Crew figures replacing the original cat glyphs from pi-speeed / pi-chonk.
+ *
+ * The working indicator uses braille spinner characters by default — the
+ * same characters pi uses for its built-in loading animation (loaders.ts
+ * DEFAULT_FRAMES).  These render on ANY terminal with basic Unicode support,
+ * no custom font required.
+ *
+ * PUA glyphs (U+E700..U+E70F) from the bundled crew-vibes.ttf font are
+ * available as an opt-in alternative (set speed.indicatorStyle = "pua" in
+ * config).  Requires the font to be installed via `npm run install:crew-font`
+ * AND a terminal that renders Private Use Area codepoints.
+ */
+
+// ── Braille spinner frames (web terminal fallback) ───────────────────
+// Standard Unicode braille spinner — same characters pi uses for its
+// built-in loading animation.  Renders on ANY terminal.
+const BRAILLE_FRAMES: readonly string[] = [
+	"\u280B ", // ⠋
+	"\u2819 ", // ⠙
+	"\u2839 ", // ⠹
+	"\u2838 ", // ⠸
+	"\u283C ", // ⠼
+	"\u2834 ", // ⠴
+	"\u2826 ", // ⠦
+	"\u2827 ", // ⠧
+	"\u2807 ", // ⠇
+	"\u280F ", // ⠏
+] as const;
+
+// ── PUA runner frames (opt-in) ────────────────────────────────────────
+// 16 runner poses from the bundled crew-vibes.ttf font.  Only usable when
+// the font is installed AND the terminal renders PUA codepoints correctly.
+// Each frame is one glyph + trailing space for constant 2-cell width.
+const PUA_CREW_FRAMES: readonly string[] = [
+	"\uE700 ",
+	"\uE701 ",
+	"\uE702 ",
+	"\uE703 ",
+	"\uE704 ",
+	"\uE705 ",
+	"\uE706 ",
+	"\uE707 ",
+	"\uE708 ",
+	"\uE709 ",
+	"\uE70A ",
+	"\uE70B ",
+	"\uE70C ",
+	"\uE70D ",
+	"\uE70E ",
+	"\uE70F ",
+] as const;
+
+/**
+ * Return the indicator frames for the given style.
+ *
+ * - `"braille"` (default): standard Unicode braille spinner, works everywhere
+ * - `"pua"`: runner-pose glyphs from crew-vibes.ttf, requires font install
+ */
+export function crewFrames(style: "braille" | "pua" = "pua"): readonly string[] {
+	// Web terminals (gotty, wetty) cannot render PUA glyphs — use braille.
+	if (style === "pua" && isWebTerminal()) return BRAILLE_FRAMES;
+	return style === "pua" ? PUA_CREW_FRAMES : BRAILLE_FRAMES;
+}
+
+// Re-export PUA frames for backward compatibility and direct consumers.
+export const RUN_CREW_FRAMES = PUA_CREW_FRAMES;
+
+/**
+ * Map a tok/s reading to a working-indicator frame interval in ms.
+ * Ported from pi-speeed's runcatInterval: interval = scale / speed, clamped
+ * to [min, max]. A null/zero speed falls back to the default (idle) cadence.
+ */
+export function intervalForSpeed(config: SpeedConfig, speed: number | null): number {
+	if (speed === null || !Number.isFinite(speed) || speed <= 0) return config.defaultIntervalMs;
+	return Math.max(config.minIntervalMs, Math.min(config.maxIntervalMs, Math.round(config.scale / speed)));
+}
+
+/**
+ * Pick the capacity stage index (0..levels-1) for a context-fill percent.
+ * Ported from pi-chonk's chonkIndex.
+ */
+export function capacityIndex(percent: number | null | undefined, levels = 6): number {
+	if (percent === null || percent === undefined || !Number.isFinite(percent)) return 0;
+	return Math.max(0, Math.min(levels - 1, Math.floor((Math.max(0, Math.min(100, percent)) / 100) * levels)));
+}
+
+/** The last two stages are "danger" stages and get the error color. */
+export function isDangerStage(index: number, levels: number): boolean {
+	return index >= Math.max(0, levels - 2);
+}

package/src/extension/crew-vibes/font-detect.ts

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Detect whether the crew-vibes PUA font (U+E700..U+E70F) file exists
+ * on disk.  This is a *best-effort* heuristic — file existence does NOT
+ * guarantee the terminal can render PUA glyphs (many terminals have their
+ * own font stacks).  For reliable animation, braille fallback frames are
+ * used by default; PUA frames are only activated when the user explicitly
+ * enables them via config (speed.indicatorStyle = "pua").
+ */
+
+function fontPath(): string {
+	const os = platform();
+	const home = homedir();
+	if (os === "darwin") return join(home, "Library", "Fonts", "crew-vibes.ttf");
+	if (os === "linux") return join(home, ".local", "share", "fonts", "crew-vibes.ttf");
+	if (os === "win32") {
+		const local = process.env.LOCALAPPDATA ?? join(home, "AppData", "Local");
+		return join(local, "Microsoft", "Windows", "Fonts", "crew-vibes.ttf");
+	}
+	return "";
+}
+
+let _hasFontFile: boolean | null = null;
+
+/** Returns true when crew-vibes.ttf exists in the platform font directory. */
+export function hasCrewFontFile(): boolean {
+	if (_hasFontFile !== null) return _hasFontFile;
+	const p = fontPath();
+	_hasFontFile = p !== "" && existsSync(p);
+	return _hasFontFile;
+}
+
+/** Returns true when running in a web-based terminal (gotty, wetty, etc.)
+ * where system fonts are not available for PUA rendering. */
+export function isWebTerminal(): boolean {
+	if (process.env.GOTTY || process.env.WEBTERM) return true;
+	if (process.env.TERM === "dumb") return true;
+	try {
+		// Check current process and ancestors — gotty is often the grandparent
+		// (gotty → tmux → pi), so /proc/self/cgroup may not contain it.
+		let pid = process.pid;
+		for (let i = 0; i < 6 && pid > 1; i++) {
+			const cgroup = readFileSync(`/proc/${pid}/cgroup`, "utf8");
+			if (cgroup.includes("gotty") || cgroup.includes("wetty")) return true;
+			const match = cgroup.match(/\d+:.*:(.*)/);
+			// Read PPid from status
+			const status = readFileSync(`/proc/${pid}/status`, "utf8");
+			const ppid = status.match(/^PPid:\s+(\d+)/m);
+			pid = ppid ? Number.parseInt(ppid[1], 10) : 1;
+		}
+	} catch {
+		// not Linux or /proc not available
+	}
+	return false;
+}

package/src/extension/crew-vibes/index.ts

@@ -0,0 +1,396 @@
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type CrewVibesConfig, loadConfig, PROVIDER_STATUS_ID, saveConfig } from "./config.ts";
+import { isWebTerminal } from "./font-detect.ts";
+import { fetchProviderUsage, clearProviderUsageCache } from "./provider-usage.ts";
+import { intervalForSpeed } from "./figures.ts";
+import {
+	asCrewTheme,
+	clearVibesStatus,
+	crewIndicatorFrames,
+	formatSpeed,
+	getCapacityUsage,
+	renderCapacity,
+	renderProviderUsage,
+	renderSpeedFooter,
+	renderWorkingMessage,
+	setCapacityStatus,
+	setProviderStatus,
+	setSpeedStatus,
+} from "./render.ts";
+import { SpeedAnimator, SpeedTracker } from "./speed.ts";
+import { CAT_FRAMES } from "./cat-frames.ts";
+
+export const CREW_VIBES_STATUS_KEY = "pi-crew-vibes";
+
+function isAssistantMessage(message: unknown): boolean {
+	return typeof message === "object" && message !== null && (message as { role?: string }).role === "assistant";
+}
+
+function assistantUsageOutput(message: unknown): number | undefined {
+	const usage = (message as { usage?: { output?: unknown } }).usage;
+	const output = usage?.output;
+	return typeof output === "number" && Number.isFinite(output) ? output : undefined;
+}
+
+function assistantStopReason(message: unknown): string | undefined {
+	const reason = (message as { stopReason?: unknown }).stopReason;
+	return typeof reason === "string" ? reason : undefined;
+}
+
+function assistantEventType(event: unknown): string | undefined {
+	return typeof (event as { type?: string }).type === "string" ? (event as { type: string }).type : undefined;
+}
+
+export function registerCrewVibes(pi: ExtensionAPI): void {
+	let config: CrewVibesConfig = loadConfig();
+	let lastRenderedAt = 0;
+	let currentIntervalMs = 0;
+	const speedTracker = new SpeedTracker(config.speed);
+	const footerAnimator = new SpeedAnimator(config.speed.renderIntervalMs);
+	let liveTimer: ReturnType<typeof setInterval> | undefined;
+	let footerTimer: ReturnType<typeof setInterval> | undefined;
+	let capacityTimer: ReturnType<typeof setInterval> | undefined;
+	let providerTimer: ReturnType<typeof setInterval> | undefined;
+	let lastProviderText: string | undefined;
+	let catFrameIndex = 0;
+
+	/** Strip ANSI codes to measure visible width. */
+	function visibleLen(text: string): number {
+		return text.replace(/\x1b\[[0-9;]*m/g, "").length;
+	}
+
+	/** Left-align `left`, right-align `right` on the same line.
+	 * Uses non-breaking space (U+00A0) for padding because pi's
+	 * sanitizeStatusText collapses regular spaces: / +/g → " ". */
+	function spreadLine(left: string, right: string): string {
+		const cols = process.stdout.columns || 120;
+		const padding = Math.max(2, cols - visibleLen(left) - visibleLen(right));
+		return left + "\u00A0".repeat(padding) + right;
+	}
+
+	function themeOf(ctx: ExtensionContext) {
+		return asCrewTheme(ctx.hasUI ? ctx.ui.theme : undefined);
+	}
+
+	function publishCapacity(ctx: ExtensionContext): void {
+		if (!ctx?.hasUI) return;
+		if (!config.enabled || !config.capacity.enabled) {
+			setCapacityStatus(ctx, config, undefined);
+			return;
+		}
+		const capText = renderCapacity(themeOf(ctx), config.capacity, getCapacityUsage(ctx));
+		// Combine capacity + provider on one line with spacing
+		const combined = lastProviderText ? spreadLine(capText, lastProviderText) : capText;
+		setCapacityStatus(ctx, config, combined);
+	}
+
+	function publishSpeedFooter(ctx: ExtensionContext, speed = footerAnimator.value()): void {
+		if (!config.enabled || !config.speed.enabled || !config.speed.footer) {
+			setSpeedStatus(ctx, config, undefined);
+			return;
+		}
+		setSpeedStatus(ctx, config, renderSpeedFooter(themeOf(ctx), config.speed, speed));
+	}
+
+	function applyIndicator(ctx: ExtensionContext, speed: number | null, force = false): void {
+		if (!ctx.hasUI || !ctx.ui.setWorkingIndicator) return;
+		if (!config.enabled || !config.speed.enabled || !config.speed.indicator) {
+			ctx.ui.setWorkingIndicator();
+			return;
+		}
+		const next = intervalForSpeed(config.speed, speed);
+		if (!force && Math.abs(next - currentIntervalMs) < 10) return;
+		ctx.ui.setWorkingIndicator({
+			frames: crewIndicatorFrames(themeOf(ctx)),
+			intervalMs: next,
+		});
+		currentIntervalMs = next;
+	}
+
+	function renderWorking(ctx: ExtensionContext, speed: number | null): void {
+		if (!config.enabled || !config.speed.enabled || !ctx.hasUI) return;
+		ctx.ui.setWorkingMessage(renderWorkingMessage(themeOf(ctx), config.speed, speed));
+	}
+
+	function stopLiveTimer(): void {
+		if (!liveTimer) return;
+		clearInterval(liveTimer);
+		liveTimer = undefined;
+	}
+
+	function stopFooterTimer(): void {
+		if (!footerTimer) return;
+		clearInterval(footerTimer);
+		footerTimer = undefined;
+	}
+
+	function stopCapacityTimer(): void {
+		if (!capacityTimer) return;
+		clearInterval(capacityTimer);
+		capacityTimer = undefined;
+	}
+
+	function stopProviderTimer(): void {
+		if (!providerTimer) return;
+		clearInterval(providerTimer);
+		providerTimer = undefined;
+	}
+
+	function startLiveTimer(ctx: ExtensionContext): void {
+		if (liveTimer || !ctx.hasUI) return;
+		liveTimer = setInterval(() => {
+			if (!config.enabled || !config.speed.enabled || !speedTracker.isStreaming) {
+				stopLiveTimer();
+				return;
+			}
+			const speed = speedTracker.liveTokS();
+			applyIndicator(ctx, speed);
+			renderWorking(ctx, speed);
+			// Update cat animation frame in web terminals
+			if (isWebTerminal()) {
+				catFrameIndex = (catFrameIndex + 1) % CAT_FRAMES.length;
+				ctx.ui.setWidget("crew-vibes-cat", [...CAT_FRAMES[catFrameIndex]], { placement: "aboveEditor" });
+			}
+		}, config.speed.renderIntervalMs);
+		liveTimer.unref?.();
+	}
+
+	function startFooterTimer(ctx: ExtensionContext): void {
+		if (footerTimer || !ctx.hasUI) return;
+		footerTimer = setInterval(() => {
+			if (!config.enabled || !config.speed.enabled) {
+				stopFooterTimer();
+				return;
+			}
+			publishSpeedFooter(ctx);
+			if (!footerAnimator.isAnimating()) stopFooterTimer();
+		}, config.speed.renderIntervalMs);
+		footerTimer.unref?.();
+	}
+
+	function startCapacityTimer(ctx: ExtensionContext): void {
+		if (capacityTimer) return;
+		const interval = Math.max(250, config.capacity.refreshIntervalMs);
+		capacityTimer = setInterval(() => publishCapacity(ctx), interval);
+		capacityTimer.unref?.();
+	}
+
+	function startProviderTimer(ctx: ExtensionContext): void {
+		if (providerTimer) return;
+		if (!config.capacity.providerUsage) return;
+		const interval = Math.max(10000, config.capacity.providerRefreshMs);
+
+		async function tick(): Promise<void> {
+			if (!config.enabled || !config.capacity.providerUsage) {
+				stopProviderTimer();
+				return;
+			}
+			try {
+				const usage = await fetchProviderUsage(config.capacity.providerRefreshMs);
+				lastProviderText = renderProviderUsage(themeOf(ctx), usage);
+				// Re-render combined capacity + provider line
+				publishCapacity(ctx);
+			} catch {
+				// Never crash on provider fetch failure
+				lastProviderText = undefined;
+				publishCapacity(ctx);
+			}
+		}
+
+		tick(); // Fetch immediately on start
+		providerTimer = setInterval(tick, interval);
+		providerTimer.unref?.();
+	}
+
+	function resetWorking(ctx: ExtensionContext): void {
+		applyIndicator(ctx, null, true);
+		renderWorking(ctx, speedTracker.lastTokS);
+	}
+
+	function applyConfig(ctx: ExtensionContext): void {
+		saveConfig(config);
+		speedTracker.updateConfig(config.speed);
+		footerAnimator.updateDuration(config.speed.renderIntervalMs);
+		if (!config.enabled) {
+			stopLiveTimer();
+			stopFooterTimer();
+			stopCapacityTimer();
+			stopProviderTimer();
+			clearVibesStatus(ctx);
+			return;
+		}
+		publishCapacity(ctx);
+		publishSpeedFooter(ctx);
+		if (config.capacity.providerUsage) startProviderTimer(ctx);
+	}
+
+	pi.on("session_start", (_event, ctx) => {
+		stopLiveTimer();
+		stopFooterTimer();
+		stopCapacityTimer();
+		stopProviderTimer();
+		config = loadConfig();
+		speedTracker.updateConfig(config.speed);
+		footerAnimator.updateDuration(config.speed.renderIntervalMs);
+		speedTracker.resetSession();
+		footerAnimator.reset(null);
+		clearProviderUsageCache();
+		if (!config.enabled) {
+			clearVibesStatus(ctx);
+			return;
+		}
+		publishCapacity(ctx);
+		publishSpeedFooter(ctx);
+		startCapacityTimer(ctx);
+		startProviderTimer(ctx);
+		// Set the working indicator early (matches pi's official working-indicator
+		// example) so pi has the custom frames configured before streaming begins.
+		// Calls before the loading animation exists are ignored, so we re-apply on
+		// agent_start/message_update as well.
+		applyIndicator(ctx, null, true);
+	});
+
+	pi.on("agent_start", (_event, ctx) => {
+		if (!config.enabled) return;
+		resetWorking(ctx);
+	});
+
+	pi.on("turn_start", (_event, ctx) => {
+		if (!config.enabled) return;
+		resetWorking(ctx);
+	});
+
+	pi.on("message_start", (event, ctx) => {
+		if (!config.enabled || !config.speed.enabled || !isAssistantMessage(event.message)) return;
+		speedTracker.startMessage();
+		footerAnimator.reset(speedTracker.lastTokS);
+		startLiveTimer(ctx);
+		lastRenderedAt = 0;
+		// Show cat widget in web terminals
+		if (isWebTerminal() && ctx.hasUI) {
+			ctx.ui.setWidget("crew-vibes-cat", [...CAT_FRAMES[0]], { placement: "aboveEditor" });
+		}
+	});
+
+	pi.on("message_update", (event, ctx) => {
+		if (!config.enabled || !config.speed.enabled || !isAssistantMessage(event.message) || !speedTracker.isStreaming) return;
+
+		const ev = event.assistantMessageEvent;
+		const type = assistantEventType(ev);
+		if (type === "text_delta" || type === "thinking_delta") {
+			const delta = (ev as { delta?: string }).delta ?? "";
+			speedTracker.recordDelta(delta, assistantUsageOutput(event.message));
+		}
+		if (type === "start") resetWorking(ctx);
+
+		const now = Date.now();
+		if (now - lastRenderedAt < config.speed.renderIntervalMs && type !== "done") return;
+		lastRenderedAt = now;
+
+		const speed = speedTracker.liveTokS();
+		applyIndicator(ctx, speed);
+		renderWorking(ctx, speed);
+	});
+
+	pi.on("message_end", (event, ctx) => {
+		if (!isAssistantMessage(event.message)) return;
+		publishCapacity(ctx);
+		if (!config.enabled || !config.speed.enabled || !speedTracker.isStreaming) return;
+
+		const completed = speedTracker.finishMessage(assistantUsageOutput(event.message) ?? 0, assistantStopReason(event.message));
+		if (!completed) return;
+
+		footerAnimator.setTarget(speedTracker.sessionAvgTokS());
+		publishSpeedFooter(ctx);
+		startFooterTimer(ctx);
+		applyIndicator(ctx, speedTracker.lastTokS);
+		// Remove cat widget on message end
+		if (isWebTerminal() && ctx.hasUI) {
+			ctx.ui.setWidget("crew-vibes-cat", undefined);
+		}
+	});
+
+	pi.on("turn_end", () => {
+		speedTracker.stopMessage();
+		stopLiveTimer();
+	});
+
+	pi.on("agent_end", (_event, ctx) => {
+		speedTracker.stopMessage();
+		stopLiveTimer();
+		if (ctx && config.enabled && ctx.hasUI) {
+			applyIndicator(ctx, speedTracker.lastTokS);
+			ctx.ui.setWorkingMessage();
+			if (isWebTerminal()) ctx.ui.setWidget("crew-vibes-cat", undefined);
+		}
+	});
+
+	pi.on("model_select", (_event, ctx) => publishCapacity(ctx));
+	pi.on("session_compact", (_event, ctx) => publishCapacity(ctx));
+	pi.on("session_tree", (_event, ctx) => publishCapacity(ctx));
+
+	pi.on("session_shutdown", (_event, ctx) => {
+		stopLiveTimer();
+		stopFooterTimer();
+		stopCapacityTimer();
+		stopProviderTimer();
+		clearVibesStatus(ctx);
+		if (ctx.hasUI) ctx.ui.setWidget("crew-vibes-cat", undefined);
+	});
+
+	async function handleCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
+		const tokens = args.trim().split(/\s+/).filter(Boolean);
+		const [first, second] = tokens;
+
+		const mutate = (next: CrewVibesConfig): void => {
+			config = next;
+			applyConfig(ctx);
+		};
+
+		if (!first) {
+			const speed = speedTracker.liveTokS();
+			const usage = getCapacityUsage(ctx);
+			const stage = config.capacity.icons.length
+				? config.capacity.labels[
+						Math.max(
+							0,
+							Math.min(
+								config.capacity.labels.length - 1,
+								Math.floor(((usage.percent ?? 0) / 100) * config.capacity.labels.length),
+							),
+						)
+					]
+				: "?";
+			ctx.ui.notify(
+				`crew-vibes: ${config.enabled ? "on" : "off"} · speed ${config.speed.enabled ? "on" : "off"} (${formatSpeed(config.speed, speed)}) · capacity ${config.capacity.enabled ? "on" : "off"} (${stage})`,
+				"info",
+			);
+			return;
+		}
+
+		if (first === "on" || first === "off") {
+			mutate({ ...config, enabled: first === "on" });
+			ctx.ui.notify(`crew-vibes ${first === "on" ? "enabled" : "disabled"}`, "info");
+			return;
+		}
+
+		if (first === "speed" && (second === "on" || second === "off")) {
+			mutate({ ...config, speed: { ...config.speed, enabled: second === "on" } });
+			ctx.ui.notify(`crew-vibes speed ${second === "on" ? "enabled" : "disabled"}`, "info");
+			return;
+		}
+
+		if (first === "capacity" && (second === "on" || second === "off")) {
+			mutate({ ...config, capacity: { ...config.capacity, enabled: second === "on" } });
+			ctx.ui.notify(`crew-vibes capacity ${second === "on" ? "enabled" : "disabled"}`, "info");
+			return;
+		}
+
+		ctx.ui.notify("Usage: /team-vibes [on|off|speed on|off|capacity on|off]", "error");
+	}
+
+	pi.registerCommand("team-vibes", {
+		description: "Toggle crew-vibes speed + context meters (on/off, speed, capacity)",
+		handler: handleCommand,
+	});
+}