pi-cockpit 0.3.0 → 0.5.0

package/src/stack-widget.ts

@@ -1,111 +1,142 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { TUI } from "@earendil-works/pi-tui";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { renderAgents, renderTodos, type PaintTheme, type WidthUtils } from "./render.ts";
-import { fitLineByPriority, type PrioritizedSegment } from "./layout.ts";
-import { resolveGlyphs, spinFrame } from "./icons.ts";
-import { panelRows } from "./viewport.ts";
-import type { AgentRow, CockpitConfig, TodoItem } from "./types.ts";
-
-export interface TodoWidgetDeps {
-	getTodos: () => TodoItem[];
-	getConfig: () => CockpitConfig;
-	/** False when no redraw loop is running, so spinners must not freeze mid-cycle. */
-	isAnimating?: () => boolean;
-}
-
-export interface AgentWidgetDeps {
-	getAgents: () => AgentRow[];
-	getConfig: () => CockpitConfig;
-	isRunning: () => boolean;
-	isAnimating?: () => boolean;
-}
-
-const UTILS: WidthUtils = { measure: visibleWidth, clip: truncateToWidth };
-
-// The TUI exposes the live terminal size, but a widget must never fail to render
-// because a host handed it a stub without one.
-export function terminalRows(tui: TUI): number | undefined {
-	try {
-		const rows = tui.terminal?.rows;
-		return typeof rows === "number" && rows > 0 ? rows : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-// Todo widget: pinned above the editor (setWidget "cockpit-stack", aboveEditor).
-export function makeTodoWidget(deps: TodoWidgetDeps) {
-	return (tui: TUI, theme: Theme) => {
-		const paint: PaintTheme = theme;
-		return {
-			render(width: number): string[] {
-				const cfg = deps.getConfig();
-				const todos = deps.getTodos();
-				if (todos.length === 0) return [];
-				const g = resolveGlyphs(cfg.icons.mode);
-				const now = Date.now();
-				const spin = spinFrame(g, now, deps.isAnimating?.() ?? true);
-				const opts = {
-					glyphs: g,
-					spin,
-					now,
-					expanded: cfg.todoExpanded,
-					maxRows: panelRows(terminalRows(tui)),
-				};
-				return renderTodos(todos, cfg.todoExpanded ? "list" : cfg.todoMode, width, paint, UTILS, opts);
-			},
-			invalidate(): void {},
-			dispose(): void {},
-		};
-	};
-}
-
-// Agent widget: pinned below the editor, near the input box (setWidget "cockpit-agents", belowEditor).
-export function makeAgentWidget(deps: AgentWidgetDeps) {
-	return (tui: TUI, theme: Theme) => {
-		const paint: PaintTheme = theme;
-		return {
-			render(width: number): string[] {
-				const cfg = deps.getConfig();
-				const agents = deps.getAgents();
-				if (agents.length === 0) return [];
-				const g = resolveGlyphs(cfg.icons.mode);
-				const now = Date.now();
-				const animating = deps.isAnimating?.() ?? true;
-				const spin = spinFrame(g, now, animating);
-				const running = deps.isRunning();
-				// The panel budget covers the roster header and its rows.
-				const panel = panelRows(terminalRows(tui));
-				const rosterRows = panel === undefined
-					? undefined
-					: Math.max(1, panel - 1);
-				const opts = { glyphs: g, spin, now, maxRows: rosterRows };
-				const dot = theme.fg(running ? "success" : "muted", running ? g.dotRunning : g.dotIdle);
-				const failedCount = agents.filter((a) => a.status === "failed").length;
-				const runCount = agents.filter((a) => a.status === "running" || a.status === "retrying").length;
-				const pendingCount = agents.filter((a) => a.status === "pending").length;
-				const sleepingCount = agents.filter((a) => a.status === "sleeping").length;
-				// This header owns the roster summary, so compact mode must not print
-				// its own count line right underneath saying the same thing.
-				const headerSegs: PrioritizedSegment[] = [
-					{ text: dot, priority: 100, clippable: false },
-					{ text: theme.fg("muted", "Agents"), priority: 90, clippable: false },
-				];
-				if (failedCount) {
-					headerSegs.push({ text: theme.fg("error", `${failedCount} failed`), priority: 95, clippable: false });
-				}
-				if (runCount) headerSegs.push({ text: theme.fg("dim", `${runCount} running`), priority: 80, clippable: false });
-				if (pendingCount) headerSegs.push({ text: theme.fg("dim", `${pendingCount} pending`), priority: 60, clippable: false });
-				if (sleepingCount) headerSegs.push({ text: theme.fg("dim", `${sleepingCount} sleeping`), priority: 50, clippable: false });
-				const lines: string[] = [];
-				// Was the one line in the package pushed without any width clipping.
-				lines.push(fitLineByPriority(headerSegs, width, UTILS, theme.fg("dim", g.separator), g.ellipsis));
-				lines.push(...renderAgents(agents, cfg.agentsMode, width, paint, UTILS, { ...opts, withHead: false }));
-				return lines;
-			},
-			invalidate(): void {},
-			dispose(): void {},
-		};
-	};
-}
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { renderAgents, renderTodos, type PaintTheme, type WidthUtils } from "./render.ts";
+import { fitLineByPriority, type PrioritizedSegment } from "./layout.ts";
+import { resolveGlyphs, spinFrame } from "./icons.ts";
+import { panelRows } from "./viewport.ts";
+import type { AgentRow, CockpitConfig, TodoItem } from "./types.ts";
+
+export interface TodoWidgetDeps {
+	getTodos: () => TodoItem[];
+	getConfig: () => CockpitConfig;
+	/** False when no redraw loop is running, so spinners must not freeze mid-cycle. */
+	isAnimating?: () => boolean;
+}
+
+export interface AgentWidgetDeps {
+	getAgents: () => AgentRow[];
+	getConfig: () => CockpitConfig;
+	isRunning: () => boolean;
+	isAnimating?: () => boolean;
+}
+
+const UTILS: WidthUtils = { measure: visibleWidth, clip: truncateToWidth };
+
+// The TUI exposes the live terminal size, but a widget must never fail to render
+// because a host handed it a stub without one.
+export function terminalRows(tui: TUI): number | undefined {
+	try {
+		const rows = tui.terminal?.rows;
+		return typeof rows === "number" && rows > 0 ? rows : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function visibleAgentRows(rows: AgentRow[]): AgentRow[] {
+	const byId = new Map(rows.map((row) => [row.correlationId, row]));
+	return rows.filter((row) => !row.agent.startsWith("graph(")).map((row) => {
+		let parent = row.parentCorrelationId;
+		const visited = new Set([row.correlationId]);
+		while (parent) {
+			if (visited.has(parent)) {
+				parent = undefined;
+				break;
+			}
+			visited.add(parent);
+			const parentRow = byId.get(parent);
+			if (!parentRow || !parentRow.agent.startsWith("graph(")) break;
+			parent = parentRow.parentCorrelationId;
+		}
+		return parent === row.parentCorrelationId ? row : { ...row, parentCorrelationId: parent };
+	});
+}
+
+// Todo widget: pinned above the editor (setWidget "cockpit-stack", aboveEditor).
+export function makeTodoWidget(deps: TodoWidgetDeps) {
+	return (tui: TUI, theme: Theme) => {
+		const paint: PaintTheme = theme;
+		return {
+			render(width: number): string[] {
+				const cfg = deps.getConfig();
+				const todos = deps.getTodos();
+				if (todos.length === 0) return [];
+				const g = resolveGlyphs(cfg.icons.mode);
+				const now = Date.now();
+				const spin = spinFrame(g, now, deps.isAnimating?.() ?? true);
+				const opts = {
+					glyphs: g,
+					spin,
+					now,
+					expanded: cfg.todoExpanded,
+					maxRows: panelRows(terminalRows(tui)),
+				};
+				return renderTodos(todos, cfg.todoExpanded ? "list" : cfg.todoMode, width, paint, UTILS, opts);
+			},
+			invalidate(): void {},
+			dispose(): void {},
+		};
+	};
+}
+
+// Agent widget: pinned below the editor, near the input box (setWidget "cockpit-agents", belowEditor).
+export function makeAgentWidget(deps: AgentWidgetDeps) {
+	return (tui: TUI, theme: Theme) => {
+		const paint: PaintTheme = theme;
+		return {
+			render(width: number): string[] {
+				const cfg = deps.getConfig();
+				// graph(...) is the dispatch container, not an additional worker. Keep it
+				// in AgentsStore for linkage and cleanup, and bridge its visible descendants
+				// to the nearest non-graph ancestor for rendering.
+				const roster = visibleAgentRows(deps.getAgents());
+				if (roster.length === 0) return [];
+				// Quiet mode keeps the roster fully expanded (role, task, state, duration,
+				// tool, tokens) but strips the live streaming tail: that per-message text
+				// updates on every teammate message and is exactly the dynamic noise quiet
+				// mode exists to suppress. Header counts are tail-independent, so reading
+				// them from the stripped rows leaves the summary unchanged.
+				const agents = cfg.quietMode
+					? roster.map((row) => (row.tail ? { ...row, tail: "" } : row))
+					: roster;
+				const g = resolveGlyphs(cfg.icons.mode);
+				const now = Date.now();
+				const animating = deps.isAnimating?.() ?? true;
+				const spin = spinFrame(g, now, animating);
+				const running = deps.isRunning();
+
+				// The panel budget covers the roster header and its rows.
+				const panel = panelRows(terminalRows(tui));
+				const rosterRows = panel === undefined
+					? undefined
+					: Math.max(1, panel - 1);
+				const opts = { glyphs: g, spin, now, maxRows: rosterRows };
+				const dot = theme.fg(running ? "success" : "muted", running ? g.dotRunning : g.dotIdle);
+				const failedCount = agents.filter((a) => a.status === "failed").length;
+				const runCount = agents.filter((a) => a.status === "running" || a.status === "retrying").length;
+				const pendingCount = agents.filter((a) => a.status === "pending").length;
+				const sleepingCount = agents.filter((a) => a.status === "sleeping").length;
+				// This header owns the roster summary, so compact mode must not print
+				// its own count line right underneath saying the same thing.
+				const headerSegs: PrioritizedSegment[] = [
+					{ text: dot, priority: 100, clippable: false },
+					{ text: theme.fg("muted", "Agents"), priority: 90, clippable: false },
+				];
+				if (failedCount) {
+					headerSegs.push({ text: theme.fg("error", `${failedCount} failed`), priority: 95, clippable: false });
+				}
+				if (runCount) headerSegs.push({ text: theme.fg("dim", `${runCount} running`), priority: 80, clippable: false });
+				if (pendingCount) headerSegs.push({ text: theme.fg("dim", `${pendingCount} pending`), priority: 60, clippable: false });
+				if (sleepingCount) headerSegs.push({ text: theme.fg("dim", `${sleepingCount} sleeping`), priority: 50, clippable: false });
+				const lines: string[] = [];
+				// Was the one line in the package pushed without any width clipping.
+				lines.push(fitLineByPriority(headerSegs, width, UTILS, theme.fg("dim", g.separator), g.ellipsis));
+				lines.push(...renderAgents(agents, cfg.agentsMode, width, paint, UTILS, { ...opts, withHead: false }));
+				return lines;
+			},
+			invalidate(): void {},
+			dispose(): void {},
+		};
+	};
+}

package/src/thinking-fold.ts

@@ -0,0 +1,86 @@
+// Thinking-fold control through pi's native app.thinking.toggle action.
+//
+// pi's extension API can rename the hidden-thinking label but cannot hide
+// thinking blocks: the visibility flag (hideThinkingBlock) is private to
+// interactive mode. The sanctioned reach point is the editor's actionHandlers
+// map — pi's own setCustomEditorComponent copies it across the jiti module
+// boundary with this same duck typing ("instanceof fails across jiti module
+// boundaries"), and pasteToEditor injects synthetic editor input the same way.
+//
+// State ownership stays with pi: the toggle handler persists through pi's
+// settingsManager, and Ctrl+T / /settings remain authoritative. cockpit reads
+// pi's settings files only to decide whether a dispatch is needed, and never
+// writes them.
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+
+const THINKING_TOGGLE_ACTION = "app.thinking.toggle";
+
+function asChildren(value: unknown): Component[] | undefined {
+	if (typeof value !== "object" || value === null) return undefined;
+	const children = (value as { children?: unknown }).children;
+	return Array.isArray(children) ? (children as Component[]) : undefined;
+}
+
+/**
+ * Find the handler pi wired for app.thinking.toggle on the editor. Walks the
+ * TUI component tree and duck-types the actionHandlers Map. Returns undefined
+ * when the editor is not mounted or pi moved the action map.
+ */
+export function findThinkingToggle(tui: TUI): (() => void) | undefined {
+	const stack: Component[] = [...(asChildren(tui) ?? [])];
+	const seen = new Set<Component>();
+	while (stack.length > 0) {
+		const node = stack.pop() as Component;
+		if (seen.has(node)) continue;
+		seen.add(node);
+		const handlers = (node as { actionHandlers?: unknown }).actionHandlers;
+		if (handlers instanceof Map) {
+			const toggle = handlers.get(THINKING_TOGGLE_ACTION);
+			if (typeof toggle === "function") return toggle as () => void;
+		}
+		const children = asChildren(node);
+		if (children) stack.push(...children);
+	}
+	return undefined;
+}
+
+function readHideFlag(path: string): boolean | undefined {
+	try {
+		if (!existsSync(path)) return undefined;
+		const parsed = JSON.parse(readFileSync(path, "utf-8")) as { hideThinkingBlock?: unknown };
+		return typeof parsed.hideThinkingBlock === "boolean" ? parsed.hideThinkingBlock : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Effective hideThinkingBlock the way pi merges it: project settings override
+ * global, and a missing or unparseable flag defaults to false — the same
+ * `?? false` settingsManager applies. (An untrusted project's override is not
+ * visible here; pi ignores it at runtime. Such a project-level flag for this
+ * key is a pathological case cockpit does not try to second-guess.)
+ */
+export function readHideThinkingBlock(cwd: string): boolean {
+	const global = readHideFlag(join(getAgentDir(), "settings.json"));
+	const project = readHideFlag(join(cwd, CONFIG_DIR_NAME, "settings.json"));
+	return project ?? global ?? false;
+}
+
+/**
+ * Bring pi's thinking visibility to the wanted state via the native toggle.
+ * Reads first so the dispatch never flips the setting the wrong way; returns
+ * true when the wanted state holds afterwards, false when the editor or its
+ * action handler is unreachable (non-TUI mode, startup race, pi refactor).
+ */
+export function ensureThinkingFolded(tui: TUI | undefined, cwd: string, hidden: boolean): boolean {
+	if (!tui) return false;
+	const toggle = findThinkingToggle(tui);
+	if (!toggle) return false;
+	if (readHideThinkingBlock(cwd) !== hidden) toggle();
+	return true;
+}

package/src/thinking-timer.ts

@@ -0,0 +1,224 @@
+// Live elapsed-time labels for folded thinking rows.
+//
+// Pi renders one static label ("thoughts") per hidden thinking run. This
+// module upgrades that label while the fold itself stays pi's: while the model
+// is thinking, the row shows a spinner and the running elapsed time; when the
+// run ends, the row settles to the actual duration ("thoughts · 8.4s").
+//
+// Label targeting: pi's ctx.ui.setHiddenThinkingLabel is global — it rewrites
+// every assistant message component. A final duration belongs to one message,
+// so it is written per component instance instead: the streaming component
+// stays mounted in the chat container after message_end (pi only clears its
+// reference), so a duck-typed walk — the same pattern thinking-fold.ts uses
+// for actionHandlers — can address exactly the row that just finished
+// thinking. When the walk finds nothing (non-TUI mode, pi refactor), the
+// global label API is the degraded fallback: the animation still runs, and
+// the final duration lingers briefly before the base label returns.
+
+import type { AssistantMessageEvent } from "@earendil-works/pi-ai";
+import type { TUI } from "@earendil-works/pi-tui";
+import { ANIMATION_PERIOD_MS, spinFrame, type IconGlyphs } from "./icons.ts";
+
+/**
+ * Duck-typed AssistantMessageComponent: the two public setters pi gives it.
+ * No other component in pi's chat tree exposes this pair.
+ */
+export interface ThinkingLabelTarget {
+	setHiddenThinkingLabel(label: string): void;
+	setHideThinkingBlock(hide: boolean): void;
+}
+
+function isThinkingLabelTarget(node: object): node is ThinkingLabelTarget {
+	const candidate = node as Partial<ThinkingLabelTarget>;
+	return (
+		typeof candidate.setHiddenThinkingLabel === "function"
+		&& typeof candidate.setHideThinkingBlock === "function"
+	);
+}
+
+/**
+ * Collect label targets in document order. The newest assistant message is
+ * always the last target: pi appends the streaming component to the chat
+ * container on message_start, and later siblings (tool executions, the next
+ * message) are not targets.
+ */
+export function findThinkingLabelTargets(tui: TUI): ThinkingLabelTarget[] {
+	const targets: ThinkingLabelTarget[] = [];
+	const seen = new Set<unknown>();
+	const walk = (node: unknown): void => {
+		if (typeof node !== "object" || node === null || seen.has(node)) return;
+		seen.add(node);
+		if (isThinkingLabelTarget(node)) targets.push(node);
+		const children = (node as { children?: unknown }).children;
+		if (Array.isArray(children)) {
+			for (const child of children) walk(child);
+		}
+	};
+	walk(tui);
+	return targets;
+}
+
+export function formatThinkingDuration(ms: number): string {
+	if (!Number.isFinite(ms) || ms <= 0) return "0.0s";
+	if (ms < 10_000) return `${(ms / 1000).toFixed(1)}s`;
+	const totalSeconds = Math.round(ms / 1000);
+	if (totalSeconds < 60) return `${totalSeconds}s`;
+	const minutes = Math.floor(totalSeconds / 60);
+	return `${minutes}m${String(totalSeconds % 60).padStart(2, "0")}s`;
+}
+
+export interface ThinkingTimerOptions {
+	getTui: () => TUI | undefined;
+	/** Instance label writes do not schedule a paint; the owner must. */
+	requestRender: () => void;
+	/** Label folded rows currently show; undefined means pi's own default. */
+	getBaseLabel: () => string | undefined;
+	getGlyphs: () => IconGlyphs;
+	/** Effective hideThinkingBlock — labels only render while thinking is folded. */
+	isThinkingHidden: () => boolean;
+	isEnabled: () => boolean;
+	/** Global label fallback for when no component instance is reachable. */
+	setGlobalLabel: (label: string | undefined) => void;
+	now?: () => number;
+	/** How long the fallback final label lingers before the base returns. */
+	settleMs?: number;
+}
+
+const DEFAULT_SETTLE_MS = 5_000;
+
+export class ThinkingFoldTimer {
+	readonly #options: ThinkingTimerOptions;
+	#startedAt: number | undefined;
+	#ticker: ReturnType<typeof setInterval> | undefined;
+	#settleTimer: ReturnType<typeof setTimeout> | undefined;
+	// Invalidates pending settle restores across stop/reset boundaries so a
+	// late timer can never rewrite a label a newer run already owns.
+	#generation = 0;
+
+	constructor(options: ThinkingTimerOptions) {
+		this.#options = options;
+	}
+
+	onAssistantMessageEvent(event: AssistantMessageEvent | undefined): void {
+		if (!event) return;
+		if (!this.#options.isEnabled()) {
+			this.stop();
+			return;
+		}
+		if (event.type === "thinking_start") this.#begin();
+		else if (event.type === "thinking_end") this.#finish();
+	}
+
+	/**
+	 * Settle an interrupted run: message_end fires for aborted and failed
+	 * messages too (agent_end only removes the row afterwards), so the
+	 * duration written here is still accurate and lands on a mounted row.
+	 */
+	onAssistantMessageEnd(): void {
+		if (this.#startedAt !== undefined) this.#finish();
+	}
+
+	/** One animation frame. The internal interval drives it; tests call it directly. */
+	tick(): void {
+		if (this.#startedAt === undefined) return;
+		const now = this.#now();
+		const glyphs = this.#options.getGlyphs();
+		const label = `${spinFrame(glyphs, now)} thinking ${formatThinkingDuration(now - (this.#startedAt ?? now))}`;
+		this.#paint(label);
+	}
+
+	/** The agent stopped: drop the run without settling a duration. */
+	stop(): void {
+		this.#generation++;
+		this.#clearTimers();
+		this.#startedAt = undefined;
+	}
+
+	/** Session boundary: forget the run; pi rebuilds the chat from entries. */
+	reset(): void {
+		this.#generation++;
+		this.#clearTimers();
+		this.#startedAt = undefined;
+	}
+
+	#begin(): void {
+		// The gate is per-run: when thinking is unfolded the label row is not
+		// rendered, so there is nothing to animate and no duration to keep.
+		if (!this.#options.isThinkingHidden()) return;
+		this.#startedAt = this.#now();
+		if (!this.#ticker) {
+			this.#ticker = setInterval(() => this.tick(), ANIMATION_PERIOD_MS);
+			this.#ticker.unref?.();
+		}
+		// Paint immediately so the row flips to the live label with the first
+		// frame instead of waiting a quarter second.
+		this.tick();
+	}
+
+	#finish(): void {
+		const startedAt = this.#startedAt;
+		if (startedAt === undefined) return;
+		this.#clearTimers();
+		this.#startedAt = undefined;
+		const duration = formatThinkingDuration(this.#now() - startedAt);
+		const base = this.#options.getBaseLabel() ?? "thoughts";
+		this.#paint(`${base}${this.#options.getGlyphs().separator}${duration}`, true);
+	}
+
+	#paint(label: string, settle = false): void {
+		const tui = this.#options.getTui();
+		const targets = tui ? findThinkingLabelTargets(tui) : [];
+		const target = targets.at(-1);
+		if (target) {
+			try {
+				target.setHiddenThinkingLabel(label);
+				this.#options.requestRender();
+			} catch {
+				// component may be mid-teardown; the global path recovers
+				this.#paintGlobal(label, settle);
+			}
+			return;
+		}
+		this.#paintGlobal(label, settle);
+	}
+
+	#paintGlobal(label: string, settle: boolean): void {
+		try {
+			this.#options.setGlobalLabel(label);
+		} catch {
+			// no UI surface at all — nothing to paint
+		}
+		if (!settle) return;
+		// The global label is shared by every folded row, so the final
+		// duration cannot stay: give it a moment to be read, then hand the
+		// label back to whatever the owner currently wants.
+		this.#generation++;
+		const generation = this.#generation;
+		if (this.#settleTimer) clearTimeout(this.#settleTimer);
+		this.#settleTimer = setTimeout(() => {
+			this.#settleTimer = undefined;
+			if (generation !== this.#generation) return;
+			try {
+				this.#options.setGlobalLabel(this.#options.getBaseLabel());
+			} catch {
+				// best-effort restore
+			}
+		}, this.#options.settleMs ?? DEFAULT_SETTLE_MS);
+		this.#settleTimer.unref?.();
+	}
+
+	#clearTimers(): void {
+		if (this.#ticker) {
+			clearInterval(this.#ticker);
+			this.#ticker = undefined;
+		}
+		if (this.#settleTimer) {
+			clearTimeout(this.#settleTimer);
+			this.#settleTimer = undefined;
+		}
+	}
+
+	#now(): number {
+		return this.#options.now?.() ?? Date.now();
+	}
+}