pi-subagents 0.35.0 → 0.36.0

package/src/slash/subagents-admin.ts

@@ -1,5 +1,4 @@
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
@@ -15,7 +14,7 @@ import {
 import { serializeAgent } from "../agents/agent-serializer.ts";
 import { editableAgentConfig, preservedAgentFrontmatterFields } from "../agents/agent-management.ts";
 import { findModelInfo, getSupportedThinkingLevels, toModelInfo } from "../shared/model-info.ts";
-import { editorLabel, resolveEditorCommand, runEditorAndWait } from "./subagents-editor.ts";
+import { SelectorComponent, type SelectorItem, type SelectorResult } from "./selector.ts";
 
 const ADMIN_MESSAGE_TYPE = "subagents-admin";
 const INHERIT_MODEL_CHOICE = "Default / inherit session model";
@@ -52,6 +51,10 @@ function agentChoices(agents: AgentConfig[]): Map<string, AgentConfig> {
 	}));
 }
 
+function agentSelectItems(byLabel: Map<string, AgentConfig>): SelectorItem[] {
+	return [...byLabel.keys()].map((label) => ({ value: label, label }));
+}
+
 function agentMatches(agent: AgentConfig, rawName: string): boolean {
 	const name = rawName.trim();
 	return agent.name === name || frontmatterNameForConfig(agent) === name;
@@ -156,7 +159,7 @@ async function selectAgent(ctx: ExtensionContext, args: string): Promise<AgentSe
 		if (matches.length > 1 && !ctx.hasUI) return { kind: "ambiguous", requestedName, matches };
 		if (matches.length > 1) {
 			const byLabel = agentChoices(matches);
-			const choice = await ctx.ui.select(`Multiple subagents named '${requestedName}'`, [...byLabel.keys()]);
+			const choice = await selectFromList(ctx, `Multiple subagents named '${requestedName}'`, undefined, agentSelectItems(byLabel));
 			return choice ? { kind: "selected", agent: byLabel.get(choice)! } : { kind: "cancelled" };
 		}
 		return { kind: "not-found", agents, requestedName };
@@ -164,7 +167,7 @@ async function selectAgent(ctx: ExtensionContext, args: string): Promise<AgentSe
 
 	if (!ctx.hasUI) return { kind: "not-found", agents };
 	const byLabel = agentChoices(agents);
-	const choice = await ctx.ui.select("Select subagent", [...byLabel.keys()]);
+	const choice = await selectFromList(ctx, "Select subagent", undefined, agentSelectItems(byLabel));
 	return choice ? { kind: "selected", agent: byLabel.get(choice)! } : { kind: "cancelled" };
 }
 
@@ -198,13 +201,33 @@ function metadataFor(agent: AgentConfig): string {
 	return lines.join("\n");
 }
 
+async function selectFromList(ctx: ExtensionContext, title: string, subtitle: string | undefined, items: SelectorItem[]): Promise<string | undefined> {
+	if (typeof ctx.ui.custom === "function") {
+		const result = await ctx.ui.custom<SelectorResult>(
+			(tui, theme, kb, done) => new SelectorComponent(tui, theme, kb, { title, subtitle, items, done }),
+			{ overlay: false },
+		);
+		return result?.confirmed ? result.value : undefined;
+	}
+	const flatTitle = subtitle ? `${title}\nCurrent: ${subtitle}` : title;
+	const labelToValue = new Map(items.map((item) => [item.label, item.value] as const));
+	const choice = await ctx.ui.select(flatTitle, items.map((item) => item.value));
+	return choice ? (items.find((item) => item.value === choice)?.value ?? labelToValue.get(choice)) : undefined;
+}
+
 async function chooseModel(ctx: ExtensionContext, agent: AgentConfig): Promise<string | undefined | null> {
-	const models = liveAvailableModels(ctx).map((model) => modelFullId(model));
+	const models = liveAvailableModels(ctx);
 	const current = agent.model ?? INHERIT_MODEL_CHOICE;
-	const choices = [INHERIT_MODEL_CHOICE, ...models.filter((model) => model !== agent.model)];
-	if (agent.model && !choices.includes(agent.model)) choices.splice(1, 0, agent.model);
-	const choice = await ctx.ui.select(`Select model for ${agent.name}\nCurrent: ${current}`, choices);
-	if (!choice) return null;
+	const items: SelectorItem[] = [{ value: INHERIT_MODEL_CHOICE, label: INHERIT_MODEL_CHOICE, current: !agent.model }];
+	if (agent.model && !models.some((model) => modelFullId(model) === agent.model)) {
+		items.push({ value: agent.model, label: agent.model, current: true });
+	}
+	for (const model of models) {
+		const fullId = modelFullId(model);
+		items.push({ value: fullId, label: model.id, badge: model.provider, current: fullId === agent.model });
+	}
+	const choice = await selectFromList(ctx, `Select model for ${agent.name}`, current, items);
+	if (choice === undefined) return null;
 	return choice === INHERIT_MODEL_CHOICE ? undefined : choice;
 }
 
@@ -214,18 +237,16 @@ async function chooseThinking(ctx: ExtensionContext, agent: AgentConfig): Promis
 	const modelInfo = findModelInfo(effectiveModel, availableModels, ctx.model?.provider);
 	const levels = getSupportedThinkingLevels(modelInfo);
 	const current = agent.thinking === false ? "off" : agent.thinking ?? INHERIT_THINKING_CHOICE;
-	const choices: string[] = [INHERIT_THINKING_CHOICE, ...levels];
-	if (current !== INHERIT_THINKING_CHOICE && !choices.includes(current)) choices.splice(1, 0, current);
+	const values: string[] = [INHERIT_THINKING_CHOICE, ...levels];
+	if (current !== INHERIT_THINKING_CHOICE && !values.includes(current)) values.splice(1, 0, current);
 	const modelNote = agent.model
 		? `Model: ${agent.model}`
 		: effectiveModel
 			? `Session model: ${effectiveModel}`
 			: "Model: default / inherit";
-	const choice = await ctx.ui.select(
-		`Select thinking level for ${agent.name}\n${modelNote} · Current: ${current}`,
-		choices,
-	);
-	if (!choice) return null;
+	const items: SelectorItem[] = values.map((value) => ({ value, label: value, current: value === current }));
+	const choice = await selectFromList(ctx, `Select thinking level for ${agent.name}`, `${modelNote} · ${current}`, items);
+	if (choice === undefined) return null;
 	return choice === INHERIT_THINKING_CHOICE ? undefined : choice;
 }
 
@@ -327,38 +348,17 @@ async function saveAgentSystemPrompt(ctx: ExtensionContext, agent: AgentConfig,
 	return `Updated '${agent.name}' system prompt in ${updated.filePath}.`;
 }
 
-/**
- * Round-trip the agent's system prompt through the user's external editor: write it to a
- * temp .md file, open the editor and wait for it to close, then persist the result.
- * Returns the status message, or null when nothing should be posted.
- */
 async function editSystemPrompt(ctx: ExtensionContext, agent: AgentConfig): Promise<string | null> {
 	if (!savesThroughSettings(agent, "systemPrompt")) {
 		const readOnlyMessage = readOnlyAgentMessage(agent, "systemPrompt");
 		if (readOnlyMessage) return readOnlyMessage;
 	}
-	const editor = resolveEditorCommand();
-	if (!editor) {
-		return "No editor configured. Set $VISUAL or $EDITOR (e.g. 'open -W -n -a MarkEdit').";
-	}
-	const label = editorLabel(editor);
-	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-prompt-"));
-	const safeName = path.basename(agent.name.replace(/[^a-z0-9._-]/gi, "_")) || "agent";
-	const tmpPath = path.join(dir, `${safeName}.md`);
-	try {
-		fs.writeFileSync(tmpPath, agent.systemPrompt ?? "", "utf-8");
-		ctx.ui.notify(`Editing '${agent.name}' system prompt in ${label}. Save and close the editor window to apply.`, "info");
-		ctx.ui.setStatus("subagents-edit", `Waiting for ${label} to close…`);
-		await runEditorAndWait(editor, tmpPath);
-		const edited = fs.readFileSync(tmpPath, "utf-8");
-		if (edited.replace(/\s+$/, "") === (agent.systemPrompt ?? "").replace(/\s+$/, "")) {
-			return `System prompt for '${agent.name}' left unchanged.`;
-		}
-		return await saveAgentSystemPrompt(ctx, agent, edited);
-	} finally {
-		ctx.ui.setStatus("subagents-edit", undefined);
-		try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort cleanup */ }
+	const edited = await ctx.ui.editor(`Edit '${agent.name}' system prompt`, agent.systemPrompt ?? "");
+	if (edited === undefined) return null;
+	if (edited.replace(/\s+$/, "") === (agent.systemPrompt ?? "").replace(/\s+$/, "")) {
+		return `System prompt for '${agent.name}' left unchanged.`;
 	}
+	return saveAgentSystemPrompt(ctx, agent, edited);
 }
 
 export async function openSubagentsAdmin(pi: ExtensionAPI, ctx: ExtensionContext, args = ""): Promise<void> {

package/src/tui/fleet-status.ts

@@ -0,0 +1,362 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Editor, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { AsyncJobStep, SubagentState } from "../shared/types.ts";
+
+export const FLEET_STATUS_WIDGET_KEY = "subagent-fleet-status";
+
+const MAX_AGENT_ROWS = 5;
+const REFRESH_MS = 500;
+
+type Theme = ExtensionContext["ui"]["theme"];
+type FleetStatusTui = {
+	requestRender(): void;
+};
+type FleetStatusEntry = {
+	key: string;
+	agent: string;
+	description?: string;
+	startedAt: number;
+	tokens: number;
+};
+
+export interface FleetStatusOptions {
+	refreshMs?: number;
+	maxAgentRows?: number;
+}
+
+export function formatFleetElapsed(ms: number): string {
+	return `${Math.max(0, Math.round(ms / 1000))}s`;
+}
+
+export function formatFleetTokens(count: number): string {
+	let compact: string;
+	if (count >= 1_000_000) compact = `${(count / 1_000_000).toFixed(1)}M`;
+	else if (count >= 1_000) compact = `${(count / 1_000).toFixed(1)}k`;
+	else compact = `${Math.max(0, Math.round(count))}`;
+	return `↓ ${compact} tokens`;
+}
+
+function rightAlign(left: string, right: string, width: number): string {
+	const rightWidth = visibleWidth(right);
+	const maxLeftWidth = Math.max(0, width - rightWidth - 1);
+	const leftClamped = truncateToWidth(left, maxLeftWidth);
+	const gap = Math.max(1, width - visibleWidth(leftClamped) - rightWidth);
+	return truncateToWidth(`${leftClamped}${" ".repeat(gap)}${right}`, width);
+}
+
+function isActiveState(value: string): boolean {
+	return value === "running" || value === "queued" || value === "pending";
+}
+
+export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntry[] {
+	const entries: FleetStatusEntry[] = [];
+	for (const control of state.foregroundControls.values()) {
+		if (control.activeChildren) {
+			for (const child of [...control.activeChildren.values()].sort((left, right) => left.index - right.index)) {
+				entries.push({
+					key: `foreground-active:${control.runId}:${child.index}`,
+					agent: child.agent,
+					description: child.description,
+					startedAt: child.startedAt,
+					tokens: child.tokens ?? 0,
+				});
+			}
+			continue;
+		}
+		entries.push({
+			key: `foreground-active:${control.runId}:${control.currentIndex ?? 0}`,
+			agent: control.currentAgent ?? control.mode,
+			description: control.description,
+			startedAt: control.startedAt,
+			tokens: control.tokens ?? 0,
+		});
+	}
+
+	for (const job of state.asyncJobs.values()) {
+		if (!isActiveState(job.status)) continue;
+		const startedAt = job.startedAt ?? job.updatedAt ?? Date.now();
+		const steps: AsyncJobStep[] | undefined = job.steps?.length
+			? job.steps
+			: job.agents?.map((agent, index) => {
+				const pending = job.status === "queued"
+					|| (job.mode === "chain" && !job.activeParallelGroup && index !== (job.currentStep ?? 0));
+				return { agent, index, status: pending ? "pending" : "running" };
+			});
+		if (!steps?.length) {
+			entries.push({
+				key: `async:${job.asyncId}`,
+				agent: job.mode ?? "subagent",
+				description: job.description,
+				startedAt,
+				tokens: job.totalTokens?.total ?? 0,
+			});
+			continue;
+		}
+		for (const [offset, step] of steps.entries()) {
+			if (!isActiveState(step.status)) continue;
+			const index = step.index ?? offset;
+			if (step.status === "pending" && job.mode === "chain" && !job.activeParallelGroup && index !== (job.currentStep ?? 0)) continue;
+			entries.push({
+				key: `async:${job.asyncId}:${index}`,
+				agent: step.label ? `${step.label} (${step.agent})` : step.agent,
+				description: job.description,
+				startedAt: step.startedAt ?? startedAt,
+				tokens: step.tokens?.total ?? (steps.length === 1 ? job.totalTokens?.total ?? 0 : 0),
+			});
+		}
+	}
+
+	return entries.sort((left, right) => left.startedAt - right.startedAt || left.key.localeCompare(right.key));
+}
+
+export class SubagentFleetStatus {
+	private ctx: ExtensionContext | undefined;
+	private tui: FleetStatusTui | undefined;
+	private inputUnsubscribe: (() => void) | undefined;
+	private timer: ReturnType<typeof setInterval> | undefined;
+	private widgetRegistered = false;
+	private active = false;
+	private selectedKey = "main";
+	private inspectorOpen = false;
+	private lastRenderKey = "";
+	private entries: FleetStatusEntry[] = [];
+	private readonly state: SubagentState;
+	private readonly openInspector: (itemKey: string) => Promise<void> | void;
+	private readonly refreshMs: number;
+	private readonly maxAgentRows: number;
+
+	constructor(
+		state: SubagentState,
+		openInspector: (itemKey: string) => Promise<void> | void,
+		options: FleetStatusOptions = {},
+	) {
+		this.state = state;
+		this.openInspector = openInspector;
+		this.refreshMs = options.refreshMs ?? REFRESH_MS;
+		this.maxAgentRows = options.maxAgentRows ?? MAX_AGENT_ROWS;
+	}
+
+	setContext(ctx: ExtensionContext): void {
+		if (!ctx.hasUI) return;
+		if (this.ctx?.ui === ctx.ui) {
+			this.ctx = ctx;
+			this.refresh();
+			return;
+		}
+		this.clearUiRegistration();
+		this.ctx = ctx;
+		if (typeof ctx.ui.onTerminalInput === "function") {
+			this.inputUnsubscribe = ctx.ui.onTerminalInput((data) => this.handleKey(data));
+		}
+		this.timer = setInterval(() => this.refresh(), this.refreshMs);
+		this.timer.unref?.();
+		this.refresh();
+	}
+
+	dispose(): void {
+		this.clearUiRegistration();
+		this.ctx = undefined;
+		this.entries = [];
+		this.active = false;
+		this.selectedKey = "main";
+		this.inspectorOpen = false;
+		this.lastRenderKey = "";
+	}
+
+	refresh(): void {
+		const ctx = this.ctx;
+		if (!ctx?.hasUI) return;
+		this.entries = collectFleetStatusEntries(this.state);
+		this.clampSelection();
+		if (this.inspectorOpen || this.state.fleetInspectorOpen) {
+			this.lastRenderKey = "";
+			if (this.widgetRegistered) {
+				ctx.ui.setWidget(FLEET_STATUS_WIDGET_KEY, undefined);
+				this.widgetRegistered = false;
+				this.tui = undefined;
+			}
+			return;
+		}
+		if (this.entries.length === 0) {
+			this.active = false;
+			this.selectedKey = "main";
+			this.lastRenderKey = "";
+			if (this.widgetRegistered) {
+				ctx.ui.setWidget(FLEET_STATUS_WIDGET_KEY, undefined);
+				this.widgetRegistered = false;
+				this.tui = undefined;
+			}
+			return;
+		}
+
+		const renderKey = this.getRenderKey();
+		if (!this.widgetRegistered) {
+			ctx.ui.setWidget(FLEET_STATUS_WIDGET_KEY, (tui, theme) => {
+				this.tui = tui;
+				return {
+					render: (width: number) => this.render(width, theme),
+					invalidate: () => {
+						this.lastRenderKey = "";
+					},
+					dispose: () => {
+						if (this.tui !== tui) return;
+						this.widgetRegistered = false;
+						this.tui = undefined;
+					},
+				};
+			}, { placement: "belowEditor" });
+			this.widgetRegistered = true;
+			this.lastRenderKey = renderKey;
+			return;
+		}
+		if (renderKey === this.lastRenderKey) return;
+		this.lastRenderKey = renderKey;
+		this.tui?.requestRender();
+	}
+
+	handleKey(data: string): { consume?: boolean; data?: string } | undefined {
+		const ctx = this.ctx;
+		if (!ctx?.hasUI || this.entries.length === 0 || isKeyRelease(data)) return undefined;
+		if (this.inspectorOpen) return undefined;
+		if (!this.editorHasFocus()) {
+			if (this.active) this.deactivate();
+			return undefined;
+		}
+
+		if (!this.active) {
+			const activates = matchesKey(data, "down") || matchesKey(data, "left");
+			if (!activates || ctx.ui.getEditorText() !== "") return undefined;
+			this.active = true;
+			this.selectedKey = "main";
+			this.refresh();
+			return { consume: true };
+		}
+
+		const roster = this.rosterKeys();
+		const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
+		if (matchesKey(data, "down")) {
+			this.selectedKey = roster[Math.min(roster.length - 1, selectedIndex + 1)] ?? "main";
+			this.refresh();
+			return { consume: true };
+		}
+		if (matchesKey(data, "up")) {
+			if (selectedIndex === 0) {
+				this.deactivate();
+				return { consume: true };
+			}
+			this.selectedKey = roster[selectedIndex - 1] ?? "main";
+			this.refresh();
+			return { consume: true };
+		}
+		if (matchesKey(data, "escape")) {
+			this.deactivate();
+			return { consume: true };
+		}
+		if (matchesKey(data, Key.enter)) {
+			if (this.selectedKey === "main") {
+				this.deactivate();
+				return { consume: true };
+			}
+			this.inspectorOpen = true;
+			this.refresh();
+			const selectedKey = this.selectedKey;
+			void Promise.resolve()
+				.then(() => this.openInspector(selectedKey))
+				.catch((error) => ctx.ui.notify(error instanceof Error ? error.message : String(error), "error"))
+				.finally(() => {
+					this.inspectorOpen = false;
+					this.refresh();
+				});
+			return { consume: true };
+		}
+
+		this.deactivate();
+		return undefined;
+	}
+
+	render(width: number, theme: Theme): string[] {
+		if (this.entries.length === 0) return [];
+		const roster = this.rosterKeys();
+		const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
+		const hint = this.active
+			? "↑↓ select · enter inspect · esc back"
+			: "esc to interrupt · ← for agents · ↓ to manage";
+		const lines = [truncateToWidth(`  ${theme.fg("dim", hint)}`, width), ""];
+		lines.push(truncateToWidth(`  ${this.bullet(0, selectedIndex, theme)} main`, width));
+
+		const visibleCount = Math.min(this.maxAgentRows, this.entries.length);
+		const selectedAgentIndex = Math.max(0, selectedIndex - 1);
+		const start = selectedAgentIndex < visibleCount ? 0 : selectedAgentIndex - visibleCount + 1;
+		const hiddenBelow = this.entries.length - (start + visibleCount);
+		if (start > 0) lines.push(rightAlign("", theme.fg("dim", `↑ ${start} more`), width));
+		for (let index = start; index < start + visibleCount; index++) {
+			lines.push(this.renderEntry(index + 1, selectedIndex, this.entries[index]!, width, theme));
+		}
+		if (hiddenBelow > 0) lines.push(rightAlign("", theme.fg("dim", `↓ ${hiddenBelow} more`), width));
+		return lines;
+	}
+
+	private renderEntry(rosterIndex: number, selectedIndex: number, entry: FleetStatusEntry, width: number, theme: Theme): string {
+		const description = entry.description?.replace(/\s+/g, " ").trim();
+		const left = `  ${this.bullet(rosterIndex, selectedIndex, theme)} ${theme.fg("muted", entry.agent)}${description ? `  ${description}` : ""}`;
+		const elapsed = Date.now() - entry.startedAt;
+		const right = theme.fg("dim", `${formatFleetElapsed(elapsed)} · ${formatFleetTokens(entry.tokens)}`);
+		return rightAlign(left, right, width);
+	}
+
+	private bullet(rosterIndex: number, selectedIndex: number, theme: Theme): string {
+		return rosterIndex === selectedIndex ? theme.fg("accent", "⏺") : theme.fg("dim", "◯");
+	}
+
+	private rosterKeys(): string[] {
+		return ["main", ...this.entries.map((entry) => entry.key)];
+	}
+
+	private clampSelection(): void {
+		if (!this.rosterKeys().includes(this.selectedKey)) this.selectedKey = "main";
+	}
+
+	private deactivate(): void {
+		this.active = false;
+		this.selectedKey = "main";
+		this.refresh();
+	}
+
+	private editorHasFocus(): boolean {
+		// pi-tui exposes focus mutation but no focus getter; fail closed if this compatibility seam disappears.
+		const focused = (this.tui as unknown as { focusedComponent?: unknown } | undefined)?.focusedComponent;
+		return focused instanceof Editor;
+	}
+
+	private getRenderKey(): string {
+		const now = Date.now();
+		return JSON.stringify({
+			active: this.active,
+			selected: this.selectedKey,
+			inspectorOpen: this.inspectorOpen,
+			entries: this.entries.map((entry) => [
+				entry.key,
+				entry.agent,
+				entry.description,
+				Math.round((now - entry.startedAt) / 1000),
+				entry.tokens,
+			]),
+		});
+	}
+
+	private clearUiRegistration(): void {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = undefined;
+		this.inputUnsubscribe?.();
+		this.inputUnsubscribe = undefined;
+		if (this.ctx?.hasUI && this.widgetRegistered) {
+			try {
+				this.ctx.ui.setWidget(FLEET_STATUS_WIDGET_KEY, undefined);
+			} catch {
+				// The previous extension context may already be stale during reload/session replacement.
+			}
+		}
+		this.widgetRegistered = false;
+		this.tui = undefined;
+	}
+}