pi-crew 0.9.51 → 0.9.52

package/src/ui/powerbar-publisher.ts

@@ -1,459 +0,0 @@
-import * as fs from "node:fs";
-import type { CrewUiConfig } from "../config/config.ts";
-import { listRecentRuns } from "../extension/run-index.ts";
-import { readCrewAgents } from "../runtime/crew-agent-records.ts";
-import { listLiveAgents } from "../runtime/live-agent-manager.ts";
-import type { ManifestCache } from "../runtime/manifest-cache.ts";
-import { isDisplayActiveRun } from "../runtime/process-status.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { aggregateUsage } from "../state/usage.ts";
-import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
-import { RenderCoalescer } from "./render-coalescer.ts";
-import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
-import { notificationBadge } from "./widget/widget-formatters.ts";
-
-type EventBus =
-	| {
-			emit?: (event: string, data: unknown) => void;
-			listenerCount?: (event: string) => number;
-	  }
-	| undefined;
-type StatusContext =
-	| {
-			hasUI?: boolean;
-			ui?: {
-				setStatus?: (key: string, text: string | undefined) => void;
-			};
-	  }
-	| undefined;
-
-const TASK_READ_TTL_MS = 200;
-
-function hasPowerbarConsumer(events: EventBus): boolean {
-	try {
-		return (events?.listenerCount?.("powerbar:register-segment") ?? 0) > 0 || (events?.listenerCount?.("powerbar:update") ?? 0) > 0;
-	} catch {
-		return false;
-	}
-}
-
-function setStatusFallback(ctx: StatusContext, text: string | undefined): void {
-	try {
-		if (ctx?.hasUI) ctx.ui?.setStatus?.("pi-crew", text);
-	} catch (error) {
-		logInternalError("powerbar.statusFallback", error);
-	}
-}
-
-function safeEmit(events: EventBus, event: string, data: unknown): void {
-	try {
-		events?.emit?.(event, data);
-	} catch (error) {
-		logInternalError("powerbar.safeEmit", error, `event=${event}`);
-	}
-}
-
-function readTasks(tasksPath: string): TeamTaskState[] {
-	try {
-		const parse = () => {
-			const parsed = JSON.parse(fs.readFileSync(tasksPath, "utf-8"));
-			return Array.isArray(parsed) ? (parsed as TeamTaskState[]) : [];
-		};
-		return readJsonFileCoalesced(tasksPath, TASK_READ_TTL_MS, parse);
-	} catch (error) {
-		logInternalError("powerbar.readTasks", error, tasksPath);
-		return [];
-	}
-}
-
-export function compactTokens(total: number): string {
-	return total >= 1000 ? `${Math.round(total / 1000)}k` : `${total}`;
-}
-
-export function registerPiCrewPowerbarSegments(events: EventBus, config?: CrewUiConfig): void {
-	if (config?.powerbar === false) return;
-	safeEmit(events, "powerbar:register-segment", {
-		id: "pi-crew-active",
-		label: "pi-crew active agents",
-	});
-	safeEmit(events, "powerbar:register-segment", {
-		id: "pi-crew-progress",
-		label: "pi-crew run progress",
-	});
-	safeEmit(events, "powerbar:register-segment", {
-		id: "pi-crew-steps",
-		label: "pi-crew workflow steps",
-	});
-}
-
-export function updatePiCrewPowerbar(
-	events: EventBus,
-	cwd: string,
-	config?: CrewUiConfig,
-	manifestCache?: ManifestCache,
-	snapshotCache?: RunSnapshotCache,
-	ctx?: StatusContext,
-	notificationCount = 0,
-	preloadedManifests?: TeamRunManifest[],
-): void {
-	powerbarPublisher.update(events, cwd, config, manifestCache, snapshotCache, ctx, notificationCount, preloadedManifests);
-}
-
-// --- Dedup state + coalescer live on a class instance so they survive hot-reload
-// cleanly: previously these were module-level globals (`lastActiveKey`,
-// `latestArgs`, `powerbarCoalescer`) that survived across reloads and could
-// leak between independent sessions. Encapsulating the state on an instance
-// lets `dispose()` tear it down and a fresh `new PowerbarPublisher()` start
-// from clean slate. The module-level functions remain for back-compat and
-// delegate to a process-wide singleton.
-
-interface PowerbarPayloadShape {
-	id?: string;
-	text?: string;
-	suffix?: string;
-	bar?: number;
-	color?: string;
-	icon?: string;
-	barSegments?: number;
-}
-
-function powerbarKey(payload: PowerbarPayloadShape): string {
-	return `${payload.text ?? ""}|${payload.suffix ?? ""}|${payload.bar ?? ""}|${payload.color ?? ""}|${payload.icon ?? ""}|${payload.barSegments ?? ""}`;
-}
-
-interface ActiveItem {
-	run: TeamRunManifest;
-	agents: ReturnType<typeof readCrewAgents>;
-	tasks: TeamTaskState[];
-	snapshot?: RunUiSnapshot;
-}
-
-/**
- * Build the workflow steps segment showing: ✓explore › →plan › ○execute › ○verify
- * with the current/active step highlighted using → arrow.
- */
-function buildStepsPayload(active: ActiveItem[], allTasks: TeamTaskState[]): PowerbarPayloadShape {
-	if (!active.length) {
-		return { id: "pi-crew-steps" };
-	}
-	const run = active[0]!.run;
-	const workflowName = run.workflow ?? "default";
-	// Load workflow steps
-	const workflows = allWorkflows(discoverWorkflows(run.cwd));
-	const workflow = workflows.find((w) => w.name === workflowName);
-	if (!workflow || workflow.steps.length === 0) {
-		return { id: "pi-crew-steps", text: workflowName };
-	}
-	// Build step status map from tasks
-	const stepStatus = new Map<string, "completed" | "running" | "pending">();
-	for (const task of allTasks) {
-		if (!task.stepId) continue;
-		if (!stepStatus.has(task.stepId)) {
-			if (task.status === "completed") {
-				stepStatus.set(task.stepId, "completed");
-			} else if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
-				stepStatus.set(task.stepId, "running");
-			}
-		}
-	}
-	// Format: "✓explore › →plan › ○execute › ○verify"
-	// ✓ = completed, → = running (current), ○ = pending
-	const stepParts: string[] = [];
-	for (const step of workflow.steps) {
-		const status = stepStatus.get(step.id) ?? "pending";
-		const icon = status === "completed" ? "✓" : status === "running" ? "→" : "○";
-		// Shorten long step names
-		const stepName = step.id.length > 10 ? step.id.slice(0, 9) + "…" : step.id;
-		stepParts.push(`${icon}${stepName}`);
-	}
-	const stepsText = stepParts.join(" › ");
-	// Color: accent if running step exists, success if all complete, dim otherwise
-	const hasRunningStep = [...stepStatus.values()].includes("running");
-	const allComplete = stepStatus.size === workflow.steps.length && ![...stepStatus.values()].includes("running");
-	const color = allComplete ? "success" : hasRunningStep ? "accent" : "dim";
-	return {
-		id: "pi-crew-steps",
-		text: stepsText,
-		color,
-	};
-}
-
-// --- Coalesced powerbar update ---
-
-interface PowerbarUpdateArgs {
-	events: EventBus;
-	cwd: string;
-	config?: CrewUiConfig;
-	manifestCache?: ManifestCache;
-	snapshotCache?: RunSnapshotCache;
-	ctx?: StatusContext;
-	notificationCount: number;
-	preloadedManifests?: TeamRunManifest[];
-}
-
-/**
- * Owns the per-segment dedup keys and the coalescer. Module-level functions
- * (`updatePiCrewPowerbar`, `requestPowerbarUpdate`, etc.) are thin facades
- * over a process-wide singleton so existing call sites and tests keep
- * working without code changes.
- */
-class PowerbarPublisher {
-	#lastActiveKey: string | undefined;
-	#lastProgressKey: string | undefined;
-	#lastStepsKey: string | undefined;
-	#latestArgs: PowerbarUpdateArgs | null = null;
-	readonly #coalescer: RenderCoalescer;
-
-	constructor() {
-		this.#coalescer = new RenderCoalescer(() => {
-			const a = this.#latestArgs;
-			this.#latestArgs = null;
-			if (!a) return;
-			this.update(a.events, a.cwd, a.config, a.manifestCache, a.snapshotCache, a.ctx, a.notificationCount, a.preloadedManifests);
-		}, 200);
-	}
-
-	update(
-		events: EventBus,
-		cwd: string,
-		config?: CrewUiConfig,
-		manifestCache?: ManifestCache,
-		snapshotCache?: RunSnapshotCache,
-		ctx?: StatusContext,
-		notificationCount = 0,
-		preloadedManifests?: TeamRunManifest[],
-	): void {
-		if (config?.powerbar === false) return;
-		const useStatusFallback = !hasPowerbarConsumer(events);
-		const runs = preloadedManifests ?? (manifestCache ? manifestCache.list(20) : listRecentRuns(cwd, 20));
-		const active = runs
-			.map((run) => {
-				let snapshot: RunUiSnapshot | undefined;
-				try {
-					// 1.2: render path is read-only. Use cache.get() only; the background
-					// preload loop in register.ts populates entries on its own cadence.
-					snapshot = snapshotCache?.get(run.runId);
-				} catch (error) {
-					logInternalError("powerbar.snapshot", error, run.runId);
-				}
-				if (snapshot)
-					return {
-						run: snapshot.manifest,
-						agents: snapshot.agents,
-						tasks: snapshot.tasks,
-						snapshot,
-					};
-				let agents: ReturnType<typeof readCrewAgents> = [];
-				try {
-					agents = readCrewAgents(run);
-				} catch (error) {
-					logInternalError("powerbar.readCrewAgents", error, run.runId);
-				}
-				return { run, agents, tasks: readTasks(run.tasksPath), snapshot };
-			})
-			.filter((item) => isDisplayActiveRun(item.run, item.agents));
-		if (!active.length) {
-			this.#lastActiveKey = undefined;
-			this.#lastProgressKey = undefined;
-			this.#lastStepsKey = undefined;
-			safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
-			safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
-			safeEmit(events, "powerbar:update", { id: "pi-crew-steps" });
-			return;
-		}
-		const agents = active.flatMap((item) => item.agents);
-		const tasks = active.flatMap((item) => item.tasks);
-		const running = agents.filter((agent) => agent.status === "running").length;
-		const waiting = active.reduce(
-			(sum, item) =>
-				sum +
-				(item.snapshot
-					? item.snapshot.progress.queued + (item.snapshot.progress.waiting ?? 0)
-					: item.tasks.reduce((s, t) => s + (t.status === "queued" || t.status === "waiting" ? 1 : 0), 0)),
-			0,
-		);
-		const completed = active.reduce(
-			(sum, item) =>
-				sum + (item.snapshot?.progress.completed ?? item.tasks.reduce((s, t) => s + (t.status === "completed" ? 1 : 0), 0)),
-			0,
-		);
-		const total = Math.max(
-			1,
-			active.reduce((sum, item) => sum + (item.snapshot?.progress.total ?? item.tasks.length), 0) || agents.length,
-		);
-		const usage = aggregateUsage(tasks);
-		const snapshotTokens = active.reduce(
-			(sum, item) => sum + (item.snapshot ? item.snapshot.usage.tokensIn + item.snapshot.usage.tokensOut : 0),
-			0,
-		);
-		const hasUsage = usage && (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) > 0;
-		const tokenTotal = hasUsage
-			? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0)
-			: snapshotTokens;
-		const model =
-			config?.showModel === false
-				? undefined
-				: agents
-						.find((agent) => agent.model)
-						?.model?.split("/")
-						.at(-1);
-		const tokenText = config?.showTokens === false || !tokenTotal ? undefined : compactTokens(tokenTotal);
-		const liveRunning = listLiveAgents().filter((a) => a.status === "running").length;
-		// Always show consistent status: running count + queued count from live tasks only
-		// Avoid snapshot cache for counts to prevent UI jumping
-		const runningCount = agents.filter((a) => a.status === "running").length;
-		// Count queued/waiting tasks directly from tasks array (not snapshot) for consistency
-		const queuedCount = active.reduce(
-			(sum, item) => sum + item.tasks.reduce((s, t) => s + (t.status === "queued" || t.status === "waiting" ? 1 : 0), 0),
-			0,
-		);
-		// Format: "1 running", "2 running · 1 queued", "3 queued", "idle"
-		const runningLabel = runningCount === 1 ? "1 running" : `${runningCount} running`;
-		const queuedLabel = queuedCount === 1 ? "1 queued" : `${queuedCount} queued`;
-		const crewStatus =
-			runningCount > 0 && queuedCount > 0
-				? `${runningLabel} · ${queuedLabel}`
-				: runningCount > 0
-					? runningLabel
-					: queuedCount > 0
-						? queuedLabel
-						: "idle";
-		const liveSuffix = liveRunning > 0 ? ` (${liveRunning} live)` : "";
-		const notificationText = notificationBadge(notificationCount);
-		// Always show model + tokens as suffix when available (for activePayload consistency)
-		const suffixParts = [model, tokenText].filter(Boolean);
-		const activeSuffix = suffixParts.length > 0 ? suffixParts.join(" · ") : undefined;
-		// Progress always includes token count for consistency
-		const progressSuffix = `${completed}/${total}${tokenText ? ` · ${tokenText}` : ""}`;
-		// Build complete, always-consistent fallback text AND event payload to prevent UI flickering
-		// Both fallback and events must use the SAME format - no conditional display
-		// Format: "⚙ 1 running · 1 queued · model · 30k · 0/1" (never changes based on availability)
-		const progressPart = `${completed}/${total}`;
-		const allParts = [`⚙ ${crewStatus}`, model ?? "", tokenText ?? "", progressPart].filter(Boolean);
-		const unifiedText = allParts.join(" · ");
-		// activePayload.text includes notification badge for event payload
-		const activePayload = {
-			id: "pi-crew-active",
-			icon: "⚙",
-			text: `⚙ ${crewStatus}${liveSuffix}${notificationText}${activeSuffix ? ` · ${activeSuffix}` : ""}`,
-			suffix: activeSuffix,
-			color: running ? "accent" : "warning",
-		} as const;
-		const progressPayload = {
-			id: "pi-crew-progress",
-			text: (active[0]?.run as TeamRunManifest)?.team ?? "crew",
-			bar: Math.round((completed / total) * 100),
-			suffix: progressSuffix,
-			color: completed === total ? "success" : "accent",
-			barSegments: 8,
-		} as const;
-		// Build step progress: "explorer > planner > executor > verifier" with current step highlighted
-		const stepsPayload = buildStepsPayload(active, tasks);
-		// 1.8: dedup per segment using a key over every visible field. Previously
-		// the dedup string only carried text/suffix/running, so changes to `bar`
-		// (progress %) or `color` could be swallowed and stale UI emitted again
-		// later as a single noisy burst.
-		const activeKey = powerbarKey(activePayload);
-		const progressKey = powerbarKey(progressPayload);
-		const stepsKey = powerbarKey(stepsPayload);
-		if (activeKey !== this.#lastActiveKey) {
-			this.#lastActiveKey = activeKey;
-			safeEmit(events, "powerbar:update", activePayload);
-		}
-		if (progressKey !== this.#lastProgressKey) {
-			this.#lastProgressKey = progressKey;
-			safeEmit(events, "powerbar:update", progressPayload);
-		}
-		if (stepsKey !== this.#lastStepsKey) {
-			this.#lastStepsKey = stepsKey;
-			safeEmit(events, "powerbar:update", stepsPayload);
-		}
-		// Never call setStatusFallback - crew-widget manages "pi-crew" status with its own widget format
-		// Powerbar only emits events; it does not set status directly
-	}
-
-	/**
-	 * Request a coalesced powerbar update. Multiple rapid calls are batched
-	 * into a single render pass within 200ms, preventing UI flicker from
-	 * event bursts.
-	 */
-	request(
-		events: EventBus,
-		cwd: string,
-		config?: CrewUiConfig,
-		manifestCache?: ManifestCache,
-		snapshotCache?: RunSnapshotCache,
-		ctx?: StatusContext,
-		notificationCount = 0,
-		preloadedManifests?: TeamRunManifest[],
-	): void {
-		if (config?.powerbar === false) return;
-		this.#latestArgs = {
-			events,
-			cwd,
-			config,
-			manifestCache,
-			snapshotCache,
-			ctx,
-			notificationCount,
-			preloadedManifests,
-		};
-		this.#coalescer.request();
-	}
-
-	clear(events: EventBus): void {
-		this.#lastActiveKey = undefined;
-		this.#lastProgressKey = undefined;
-		this.#lastStepsKey = undefined;
-		safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
-		safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
-		safeEmit(events, "powerbar:update", { id: "pi-crew-steps" });
-	}
-
-	/** Reset dedup state on session lifecycle events. */
-	resetDedupState(): void {
-		this.#lastActiveKey = undefined;
-		this.#lastProgressKey = undefined;
-		this.#lastStepsKey = undefined;
-	}
-
-	dispose(): void {
-		this.#coalescer.flush();
-		this.#coalescer.dispose();
-	}
-}
-
-const powerbarPublisher = new PowerbarPublisher();
-
-/**
- * Request a coalesced powerbar update. Multiple rapid calls are batched into a single
- * render pass within 200ms, preventing UI flicker from event bursts.
- */
-export function requestPowerbarUpdate(
-	events: EventBus,
-	cwd: string,
-	config?: CrewUiConfig,
-	manifestCache?: ManifestCache,
-	snapshotCache?: RunSnapshotCache,
-	ctx?: StatusContext,
-	notificationCount = 0,
-	preloadedManifests?: TeamRunManifest[],
-): void {
-	powerbarPublisher.request(events, cwd, config, manifestCache, snapshotCache, ctx, notificationCount, preloadedManifests);
-}
-
-/** Dispose the powerbar coalescer. Call during extension cleanup. */
-export function disposePowerbarCoalescer(): void {
-	powerbarPublisher.dispose();
-}
-
-export function clearPiCrewPowerbar(events: EventBus): void {
-	powerbarPublisher.clear(events);
-}
-
-/** Reset dedup state on session lifecycle events. */
-export function resetPowerbarDedupState(): void {
-	powerbarPublisher.resetDedupState();
-}

package/src/ui/render-coalescer.ts

@@ -1,101 +0,0 @@
-/**
- * RenderCoalescer — batches multiple render requests into single render passes.
- * Prevents UI flicker when many events arrive in quick succession.
- * Inspired by oh-my-pi's PROGRESS_COALESCE_MS (150ms) pattern.
- */
-import { logInternalError } from "../utils/internal-error.ts";
-
-export interface RenderCoalescerOptions {
-	/**
-	 * Invoked once per coalesce window with the number of `request()` calls
-	 * that were collapsed into the most recent scheduled render. Defaults to
-	 * a debug-scoped `logInternalError` so dropped bursts surface in logs
-	 * (gated behind PI_TEAMS_DEBUG) without callers having to wire one up.
-	 */
-	onDrop?: (droppedCount: number) => void;
-}
-
-export class RenderCoalescer {
-	#pending = false;
-	#timerId: ReturnType<typeof setTimeout> | null = null;
-	#callback: () => void;
-	#intervalMs: number;
-	#onDrop: (droppedCount: number) => void;
-	#dropped = 0;
-
-	constructor(callback: () => void, intervalMs = 32, options: RenderCoalescerOptions = {}) {
-		this.#callback = callback;
-		this.#intervalMs = intervalMs;
-		this.#onDrop =
-			options.onDrop ??
-			((count) => {
-				logInternalError(
-					"render-coalescer",
-					new Error(`coalesced ${count} dropped request(s) into a single render`),
-					undefined,
-					"debug",
-				);
-			});
-	}
-
-	/** Request a render. Will be coalesced with other requests within the interval. */
-	request(): void {
-		if (this.#pending) {
-			// A render is already scheduled — coalesce this request and bump
-			// the drop counter so the scheduled flush can report how many
-			// bursts were collapsed (useful for diagnosing UI lag).
-			this.#dropped += 1;
-			return;
-		}
-		this.#pending = true;
-		const timer = setTimeout(() => {
-			this.#pending = false;
-			this.#timerId = null;
-			const dropped = this.#dropped;
-			this.#dropped = 0;
-			if (dropped > 0) {
-				try {
-					this.#onDrop(dropped);
-				} catch {
-					/* drop callback errors are non-fatal */
-				}
-			}
-			this.#callback();
-		}, this.#intervalMs);
-		timer.unref();
-		this.#timerId = timer;
-	}
-
-	/** Force an immediate render, bypassing coalescing. */
-	flush(): void {
-		if (this.#timerId !== null) {
-			clearTimeout(this.#timerId);
-			this.#timerId = null;
-		}
-		this.#pending = false;
-		const dropped = this.#dropped;
-		this.#dropped = 0;
-		if (dropped > 0) {
-			try {
-				this.#onDrop(dropped);
-			} catch {
-				/* drop callback errors are non-fatal */
-			}
-		}
-		this.#callback();
-	}
-
-	/** Check if a render is pending. */
-	get pending(): boolean {
-		return this.#pending;
-	}
-
-	/** Clean up timers. Call when the coalescer is no longer needed. */
-	dispose(): void {
-		if (this.#timerId !== null) {
-			clearTimeout(this.#timerId);
-			this.#timerId = null;
-		}
-		this.#pending = false;
-	}
-}