pi-crew 0.9.53 → 0.9.55

package/src/ui/theme-discovery.ts

@@ -0,0 +1,199 @@
+/**
+ * Pi UI theme discovery and selection.
+ *
+ * Exposes:
+ *  - Pi UI theme discovery (builtins + custom ~/.pi/agent/themes/*.json)
+ *  - The active Pi theme
+ *  - setPiTheme() to persist a choice in ~/.pi/agent/settings.json
+ *
+ * Wired into the `team-settings themes` / `theme` subcommands.
+ */
+
+export interface PiThemeInfo {
+	/** Theme name (filename stem or builtin id). */
+	name: string;
+	/** Where it comes from. */
+	source: "builtin" | "custom";
+	/** Absolute path to the .json file, if applicable. */
+	path?: string;
+	/** Human-friendly display name from the JSON `name` field, if present. */
+	displayName?: string;
+	/** "dark" or "light" — derived from background luminance. */
+	mode?: "dark" | "light";
+}
+
+/** Builtin Pi themes shipped with the pi-coding-agent package. */
+const BUILTIN_PI_THEMES = ["dark", "light"];
+
+/**
+ * Detect whether a theme is dark or light based on its background luminance.
+ * Reads vars.bg or export.pageBg or a resolved colors ref. Returns undefined
+ * if it can't be determined.
+ */
+function detectThemeMode(json: Record<string, unknown>): "dark" | "light" | undefined {
+	const vars = json.vars as Record<string, string> | undefined;
+	const bgRaw = vars?.bg;
+	if (!bgRaw || !/^#[0-9a-fA-F]{6}$/.test(bgRaw)) return undefined;
+	const r = parseInt(bgRaw.slice(1, 3), 16);
+	const g = parseInt(bgRaw.slice(3, 5), 16);
+	const b = parseInt(bgRaw.slice(5, 7), 16);
+	// Relative luminance (ITU-R BT.709)
+	const lum = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+	return lum < 0.5 ? "dark" : "light";
+}
+
+function customThemesDir(): string {
+	const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+	return home ? `${home}/.pi/agent/themes` : "";
+}
+
+function settingsPath(): string {
+	const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+	return home ? `${home}/.pi/agent/settings.json` : "";
+}
+
+/** Discover all available Pi UI themes (builtins + custom). */
+export function discoverPiThemes(): PiThemeInfo[] {
+	const out: PiThemeInfo[] = [];
+	const seen = new Set<string>();
+
+	// Builtins
+	for (const name of BUILTIN_PI_THEMES) {
+		if (seen.has(name)) continue;
+		seen.add(name);
+		out.push({
+			name,
+			source: "builtin",
+			displayName: name,
+			mode: name === "light" ? "light" : "dark",
+		});
+	}
+
+	// Custom themes from ~/.pi/agent/themes/
+	const dir = customThemesDir();
+	try {
+		// eslint-disable-next-line @typescript-eslint/no-require-imports
+		const fs = require("node:fs");
+		if (dir && fs.existsSync(dir)) {
+			for (const file of fs.readdirSync(dir) as string[]) {
+				if (!file.endsWith(".json")) continue;
+				const name = file.slice(0, -5);
+				if (seen.has(name)) continue;
+				const fullPath = `${dir}/${file}`;
+				let displayName: string | undefined;
+				let mode: "dark" | "light" | undefined;
+				try {
+					const json = JSON.parse(fs.readFileSync(fullPath, "utf8"));
+					displayName = typeof json.name === "string" ? json.name : undefined;
+					mode = detectThemeMode(json);
+				} catch {
+					// keep undefined
+				}
+				seen.add(name);
+				out.push({
+					name,
+					source: "custom",
+					path: fullPath,
+					displayName,
+					mode,
+				});
+			}
+		}
+	} catch {
+		// directory unreadable — skip
+	}
+
+	return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Read the currently active Pi theme from ~/.pi/agent/settings.json. */
+export function getActivePiTheme(): string | undefined {
+	try {
+		// eslint-disable-next-line @typescript-eslint/no-require-imports
+		const fs = require("node:fs");
+		const p = settingsPath();
+		if (!p || !fs.existsSync(p)) return undefined;
+		const json = JSON.parse(fs.readFileSync(p, "utf8"));
+		return typeof json.theme === "string" ? json.theme : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Persist a Pi theme choice in ~/.pi/agent/settings.json. Returns the path or throws. */
+export function setPiTheme(name: string): string {
+	// eslint-disable-next-line @typescript-eslint/no-require-imports
+	const fs = require("node:fs");
+	const p = settingsPath();
+	if (!p) throw new Error("Could not determine settings path (no HOME).");
+	let settings: Record<string, unknown> = {};
+	try {
+		if (fs.existsSync(p)) {
+			settings = JSON.parse(fs.readFileSync(p, "utf8"));
+		}
+	} catch {
+		// corrupt settings — start fresh
+		settings = {};
+	}
+	settings.theme = name;
+	fs.writeFileSync(p, JSON.stringify(settings, null, 2) + "\n", "utf8");
+	return p;
+}
+
+// ---------------------------------------------------------------------------
+// Formatted listing for `team-settings themes`
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the full formatted listing of Pi UI themes for display.
+ * Shows available themes, the active selection, and switching instructions.
+ */
+export function formatThemesListing(): string {
+	const piThemes = discoverPiThemes();
+	const activePi = getActivePiTheme();
+	const lines: string[] = [];
+
+	const darkThemes = piThemes.filter((t) => t.mode !== "light");
+	const lightThemes = piThemes.filter((t) => t.mode === "light");
+
+	lines.push("═══ Theme Gallery ═══");
+	lines.push("");
+
+	// ── Dark themes ──
+	if (darkThemes.length) {
+		lines.push("Dark themes:");
+		lines.push("");
+		for (const t of darkThemes) {
+			lines.push(themeLine(t, activePi));
+		}
+		lines.push("");
+	}
+
+	// ── Light themes ──
+	if (lightThemes.length) {
+		lines.push("Light themes:");
+		lines.push("");
+		for (const t of lightThemes) {
+			lines.push(themeLine(t, activePi));
+		}
+		lines.push("");
+	}
+
+	lines.push("  Switch (live, no restart): team-settings theme <name>");
+	lines.push("  Browse interactively:      /team-settings → Themes tab");
+	lines.push("");
+
+	lines.push("Notes:");
+	lines.push("  • Switching applies live via ctx.ui.setTheme() (Pi redraws immediately).");
+	lines.push("  • Bundled crew-* themes deploy to ~/.pi/agent/themes/ on startup.");
+	lines.push(`  • ${piThemes.length} themes available (${darkThemes.length} dark, ${lightThemes.length} light).`);
+
+	return lines.join("\n");
+}
+
+function themeLine(t: PiThemeInfo, active: string | undefined): string {
+	const isActive = t.name === active;
+	const tag = isActive ? " ← active" : "";
+	const src = t.source === "builtin" ? " (builtin)" : "";
+	return `  ${isActive ? "●" : "○"} ${t.name}${src}${tag}`;
+}

package/src/ui/tool-progress-formatter.ts

@@ -0,0 +1,93 @@
+import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+
+export interface ToolProgressInput {
+	/** Subagent record id or synthetic agent label shown in the header. */
+	agentId?: string;
+	/** Subagent/run status string ("queued", "running", "blocked", ...). */
+	status: string;
+	/** Optional run id once the underlying team run has been created. */
+	runId?: string;
+	/** Timestamp (ms) when the parent tool call started. */
+	startedAt: number;
+	/** Optional manifest snapshot for richer detail. */
+	manifest?: TeamRunManifest;
+	/** Optional materialized task list for waiting/running counts. */
+	tasks?: TeamTaskState[];
+	/** Optional crew agent records to surface the currently active worker. */
+	agents?: CrewAgentRecord[];
+	/** Optional last error to surface (e.g. spawn failure). */
+	error?: string;
+}
+
+const MAX_OUTPUT_LINE = 80;
+
+function pickActiveAgent(agents: CrewAgentRecord[] | undefined): CrewAgentRecord | undefined {
+	if (!agents || agents.length === 0) return undefined;
+	return (
+		agents.find((agent) => agent.status === "running") ??
+		agents.find((agent) => agent.status === "waiting") ??
+		agents.find((agent) => agent.status === "queued") ??
+		agents[agents.length - 1]
+	);
+}
+
+function totalTokens(agent: CrewAgentRecord): number {
+	const fromProgress = agent.progress?.tokens;
+	if (typeof fromProgress === "number" && fromProgress > 0) return fromProgress;
+	const usage = agent.usage;
+	if (!usage) return 0;
+	const input = typeof usage.input === "number" ? usage.input : 0;
+	const output = typeof usage.output === "number" ? usage.output : 0;
+	return input + output;
+}
+
+function trimLine(value: string): string {
+	const oneLine = value.replace(/\s+/g, " ").trim();
+	if (oneLine.length <= MAX_OUTPUT_LINE) return oneLine;
+	return `${oneLine.slice(0, MAX_OUTPUT_LINE - 3)}...`;
+}
+
+function taskCounts(tasks: TeamTaskState[] | undefined): string | undefined {
+	if (!tasks || tasks.length === 0) return undefined;
+	const total = tasks.length;
+	const completed = tasks.filter((t) => t.status === "completed").length;
+	const buckets = new Map<string, number>();
+	for (const task of tasks) buckets.set(task.status, (buckets.get(task.status) ?? 0) + 1);
+	const summary = [...buckets.entries()].map(([status, count]) => `${status}=${count}`).join(" ");
+	return `tasks ${completed}/${total} done ${summary}`;
+}
+
+/**
+ * Format a compact 3-4 line progress block used as streaming `onUpdate`
+ * content for the `Agent` and `team` tool calls. Keeps each line short so
+ * the chat widget overlay does not jitter.
+ */
+export function formatCompactToolProgress(input: ToolProgressInput): string {
+	const elapsedSec = Math.max(0, Math.round((Date.now() - input.startedAt) / 1000));
+	const head = input.agentId ? `agent=${input.agentId}` : "agent";
+	const lines: string[] = [`${head} status=${input.status} elapsed=${elapsedSec}s`];
+
+	const counts = taskCounts(input.tasks);
+	if (counts) lines.push(`  ${counts}`);
+
+	const active = pickActiveAgent(input.agents);
+	if (active) {
+		const turns = active.progress?.turns ?? 0;
+		const tokens = totalTokens(active);
+		lines.push(`  ${active.role}->${active.agent} turn=${turns} tokens=${tokens}`);
+		if (active.progress?.currentTool) {
+			const count = active.progress.toolCount ? ` (#${active.progress.toolCount})` : "";
+			lines.push(`  tool: ${active.progress.currentTool}${count}`);
+		}
+		const recent = active.progress?.recentOutput?.at(-1);
+		if (recent?.trim()) lines.push(`  ${trimLine(recent)}`);
+	} else if (input.runId && !counts) {
+		lines.push(`  run=${input.runId} (starting)`);
+	} else if (input.error) {
+		lines.push(`  error: ${trimLine(input.error)}`);
+	} else if (!counts) {
+		lines.push("  waiting for run to start");
+	}
+	return lines.join("\n");
+}

package/src/ui/tool-renderers/brief-mode.ts

@@ -0,0 +1,225 @@
+/**
+ * Brief mode for tool result display.
+ *
+ * Inspired by @ayulab/pi-brief — shows one-line summaries instead of
+ * full output. Toggled via /crew-brief on|off, state persists across
+ * session reloads via pi.appendEntry().
+ */
+
+import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
+import { formatDuration, formatTokens, truncLine } from "../format-helpers.ts";
+import type { CrewTheme } from "../theme-adapter.ts";
+
+// ── State ──────────────────────────────────────────────────────────────
+
+const BRIEF_ENTRY_TYPE = "pi-crew.brief-state";
+let briefEnabled = false;
+
+export function isBrief(): boolean {
+	return briefEnabled;
+}
+
+export function setBrief(on: boolean): void {
+	briefEnabled = on;
+}
+
+/** Entry type for persisting brief state across session reloads. */
+export interface BriefStateEntry {
+	readonly type: "custom";
+	readonly customType: typeof BRIEF_ENTRY_TYPE;
+	readonly data: { enabled: boolean };
+}
+
+export function makeBriefEntry(enabled: boolean): BriefStateEntry {
+	return { type: "custom", customType: BRIEF_ENTRY_TYPE, data: { enabled } };
+}
+
+export function restoreBriefState(entries: Iterable<unknown>): void {
+	for (const entry of entries) {
+		if (
+			typeof entry === "object" &&
+			entry !== null &&
+			"type" in entry &&
+			(entry as Record<string, unknown>).type === "custom" &&
+			"customType" in entry &&
+			(entry as Record<string, unknown>).customType === BRIEF_ENTRY_TYPE &&
+			"data" in entry
+		) {
+			const data = (entry as Record<string, unknown>).data;
+			if (typeof data === "object" && data !== null && "enabled" in data) {
+				briefEnabled = !!(data as Record<string, unknown>).enabled;
+			}
+		}
+	}
+}
+
+export { BRIEF_ENTRY_TYPE };
+
+// ── Brief renderers ────────────────────────────────────────────────────
+
+/** Brief summary for a single tool result. */
+export function briefToolResult(toolName: string, result: { content?: unknown[] }, theme: CrewTheme): string {
+	const text = extractText(result?.content);
+	switch (toolName) {
+		case "read":
+			return briefRead(text, theme);
+		case "bash":
+			return briefBash(text, theme);
+		case "edit":
+			return briefEdit(text, theme);
+		case "write":
+			return briefWrite(text, theme);
+		case "find":
+			return briefFind(text, theme);
+		case "grep":
+			return briefGrep(text, theme);
+		case "ls":
+			return briefLs(text, theme);
+		case "team":
+			return briefTeam(result, theme);
+		case "agent":
+			return briefAgent(result, theme);
+		default:
+			return briefDefault(text, theme);
+	}
+}
+
+function briefRead(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ empty");
+	const count = text.trim().split("\n").filter(Boolean).length;
+	return theme.fg("muted", `→ ${count} lines`);
+}
+
+function briefBash(text: string, theme: CrewTheme): string {
+	if (!text?.trim()) return theme.fg("dim", "→ done");
+	const lines = text.trim().split("\n");
+	if (lines.length === 1 && lines[0]!.length < 40) {
+		return theme.fg("muted", `→ ${lines[0]}`);
+	}
+	return theme.fg("muted", `→ ${lines.length} lines`);
+}
+
+function briefEdit(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ edited");
+	if (text.includes("Error") || text.includes("error")) {
+		return theme.fg("error", "→ failed");
+	}
+	const added = (text.match(/^\+ /gm) ?? []).length;
+	const removed = (text.match(/^- /gm) ?? []).length;
+	if (added === 0 && removed === 0) {
+		return theme.fg("success", "→ edited");
+	}
+	return theme.fg("success", "→ edited ") + theme.fg("toolDiffAdded", `+${added} `) + theme.fg("toolDiffRemoved", `-${removed}`);
+}
+
+function briefWrite(text: string, theme: CrewTheme): string {
+	if (text) return theme.fg("error", `→ ${text}`);
+	return theme.fg("success", "→ written");
+}
+
+function briefFind(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ none");
+	const count = text.trim().split("\n").filter(Boolean).length;
+	return theme.fg("muted", `→ ${count} files`);
+}
+
+function briefGrep(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ none");
+	const count = text.trim().split("\n").filter(Boolean).length;
+	return theme.fg("muted", `→ ${count} matches`);
+}
+
+function briefLs(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ empty");
+	const count = text.trim().split("\n").filter(Boolean).length;
+	return theme.fg("muted", `→ ${count} entries`);
+}
+
+function briefTeam(result: { content?: unknown[] }, theme: CrewTheme): string {
+	// Try to extract structured details
+	const details = (result as Record<string, unknown>).details ?? result;
+	const d = typeof details === "object" && details !== null ? (details as Record<string, unknown>) : {};
+	const status = typeof d.status === "string" ? d.status : "";
+	const runId = typeof d.runId === "string" ? d.runId : "";
+	const icon =
+		status === "completed"
+			? theme.fg("success", "✓")
+			: status === "failed"
+				? theme.fg("error", "✗")
+				: status === "running"
+					? theme.fg("warning", "⟳")
+					: theme.fg("dim", "○");
+
+	// Agent records summary
+	const records = (d.agentRecords ?? d.results) as CrewAgentRecord[] | undefined;
+	if (records?.length) {
+		const completed = records.filter((r) => r.status === "completed").length;
+		const total = records.length;
+		const duration = computeTotalDuration(records);
+		const tokens = computeTotalTokens(records);
+		return `${icon} ${completed}/${total} tasks · ${formatDuration(duration)} · ${formatTokens(tokens)} tok`;
+	}
+
+	// Fallback: compact status line
+	const parts: string[] = [];
+	if (status) parts.push(status);
+	if (runId) parts.push(runId.slice(-8));
+	return `${icon} ${parts.join(" · ") || "done"}`;
+}
+
+function briefAgent(result: { content?: unknown[] }, theme: CrewTheme): string {
+	const d = (result as Record<string, unknown>).details ?? result;
+	const data = typeof d === "object" && d !== null ? (d as Record<string, unknown>) : {};
+	const status = typeof data.status === "string" ? data.status : "";
+	const agentId = typeof data.agentId === "string" ? data.agentId : "agent";
+	const icon =
+		status === "completed"
+			? theme.fg("success", "\u2713")
+			: status === "failed"
+				? theme.fg("error", "\u2717")
+				: theme.fg("dim", "\u25CB");
+	// P3: Show duration and tokens when available
+	const parts: string[] = [agentId];
+	if (data.durationMs) parts.push(formatDuration(data.durationMs as number));
+	if (data.totalTokens) parts.push(`${formatTokens(data.totalTokens as number)} tok`);
+	return `${icon} ${parts.join(" \u00B7 ")}`;
+}
+
+function briefDefault(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ done");
+	const first = text.split("\n")[0] ?? "";
+	return theme.fg("muted", `→ ${truncLine(first, 60)}`);
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function extractText(content: unknown[] | undefined): string {
+	if (!content) return "";
+	if (!Array.isArray(content)) return String(content);
+	return content
+		.filter((c): c is Record<string, unknown> => typeof c === "object" && c !== null && (c as Record<string, unknown>).type === "text")
+		.map((c) => String((c as Record<string, unknown>).text ?? ""))
+		.join("\n");
+}
+
+function computeTotalDuration(records: CrewAgentRecord[]): number {
+	let total = 0;
+	for (const r of records) {
+		if (r.startedAt) {
+			const start = new Date(r.startedAt).getTime();
+			const end = r.completedAt ? new Date(r.completedAt).getTime() : Date.now();
+			if (Number.isFinite(start) && Number.isFinite(end)) total += Math.max(0, end - start);
+		}
+	}
+	return total;
+}
+
+function computeTotalTokens(records: CrewAgentRecord[]): number {
+	let total = 0;
+	for (const r of records) {
+		if (r.usage) {
+			total += (r.usage.input ?? 0) + (r.usage.output ?? 0) + (r.usage.cacheWrite ?? 0);
+		}
+	}
+	return total;
+}