@ferris1225/pi-subagents 0.3.0 → 0.5.0

package/src/models.ts

@@ -0,0 +1,69 @@
+/**
+ * Model availability helpers shared by setup and sub-agent execution.
+ *
+ * A configured override can outlive a provider login, a scoped-model change, or
+ * a model rename. Keep the main session usable by replacing such overrides with
+ * the model currently selected in the main window (or the first available model)
+ * and let callers persist the repaired mapping.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export type ModelContext = Pick<ExtensionContext, "model" | "scopedModels" | "modelRegistry">;
+
+export interface ModelOverrideRepair {
+	agentModels: Record<string, string>;
+	changed: boolean;
+	replaced: number;
+	removed: number;
+	fallbackRef?: string;
+}
+
+export function modelRef(model: { provider: string; id: string }): string {
+	return `${model.provider}/${model.id}`;
+}
+
+/**
+ * Return model references usable by the current main window, with its current
+ * model first so it is the deterministic fallback for stale configuration.
+ */
+export function availableModelRefs(ctx: ModelContext): string[] {
+	const scoped = ctx.scopedModels.length > 0 ? ctx.scopedModels.map((entry) => entry.model) : undefined;
+	const models = scoped ?? ctx.modelRegistry.getAvailable();
+	const refs = [...new Set(models.map(modelRef))];
+	const currentRef = ctx.model ? modelRef(ctx.model) : undefined;
+	if (!currentRef) return refs;
+	return [currentRef, ...refs.filter((ref) => ref !== currentRef)];
+}
+
+/** Replace unavailable persisted overrides with a model usable by the main session. */
+export function repairUnavailableModelOverrides(
+	ctx: ModelContext,
+	agentModels: Record<string, string>,
+): ModelOverrideRepair {
+	const refs = availableModelRefs(ctx);
+	const available = new Set(refs);
+	const fallbackRef = refs[0];
+	const repaired: Record<string, string> = {};
+	let changed = false;
+	let replaced = 0;
+	let removed = 0;
+
+	for (const [name, configuredRef] of Object.entries(agentModels)) {
+		const ref = configuredRef.trim();
+		if (available.has(ref)) {
+			repaired[name] = ref;
+			continue;
+		}
+
+		changed = true;
+		if (fallbackRef) {
+			repaired[name] = fallbackRef;
+			replaced++;
+		} else {
+			removed++;
+		}
+	}
+
+	return { agentModels: repaired, changed, replaced, removed, fallbackRef };
+}

package/src/monitor.ts

@@ -1,238 +1,275 @@
-/**
- * Sub-agent monitor: a module-level singleton store that tracks subagent runs
- * for the current turn.
- *
- * The store notifies subscribers on every mutation so the persistent widget
- * above the editor can re-render. Each run carries timing information
- * (started/ended) and a transcript whose most recent entry is surfaced as the
- * run's current activity.
- */
-
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { UsageStats } from "./spawn.ts";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type RunStatus = "queued" | "running" | "done" | "failed";
-
-export interface TranscriptLine {
-	kind: "tool" | "text" | "status" | "error";
-	text: string;
-}
-
-export interface RunView {
-	id: number;
-	agent: string;
-	model?: string;
-	status: RunStatus;
-	usage: UsageStats;
-	transcript: TranscriptLine[];
-	/** Epoch ms when the run started executing (set on first "running" status). */
-	startedAt?: number;
-	/** Epoch ms when the run finished (set on "done"/"failed"). */
-	endedAt?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Formatting helpers
-// ---------------------------------------------------------------------------
-
-function formatTokens(count: number): string {
-	if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
-	if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
-	return String(count);
-}
-
-export function formatUsageCompact(usage: UsageStats): string {
-	const parts: string[] = [];
-	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
-	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
-	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	return parts.join(" ");
-}
-
-export function formatDuration(ms: number): string {
-	const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-	if (totalSeconds < 60) return `${totalSeconds}s`;
-	const minutes = Math.floor(totalSeconds / 60);
-	const seconds = totalSeconds % 60;
-	if (minutes < 60) return `${minutes}m${String(seconds).padStart(2, "0")}s`;
-	const hours = Math.floor(minutes / 60);
-	return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
-}
-
-/** Elapsed wall time of a run: live while running, final once finished. */
-export function formatElapsed(run: RunView, now: number = Date.now()): string {
-	if (run.startedAt === undefined) return "";
-	const end = run.endedAt ?? now;
-	return formatDuration(end - run.startedAt);
-}
-
-// ---------------------------------------------------------------------------
-// MonitorStore
-// ---------------------------------------------------------------------------
-
-export class MonitorStore {
-	private runs: RunView[] = [];
-	private nextId = 1;
-	private subscribers = new Set<() => void>();
-
-	beginTurn(): void {
-		// Clear finished runs from a previous turn, but keep any still-active
-		// (queued/running) ones so a concurrent sub-agent call is not wiped.
-		this.runs = this.runs.filter((r) => r.status === "queued" || r.status === "running");
-		this.notify();
-	}
-
-	addRun(agent: string, model?: string): number {
-		const id = this.nextId++;
-		this.runs.push({
-			id,
-			agent,
-			model,
-			status: "queued",
-			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-			transcript: [],
-		});
-		this.notify();
-		return id;
-	}
-
-	setStatus(id: number, status: RunStatus): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.status = status;
-		if (status === "running" && run.startedAt === undefined) {
-			run.startedAt = Date.now();
-		} else if ((status === "done" || status === "failed") && run.endedAt === undefined) {
-			run.endedAt = Date.now();
-		}
-		this.notify();
-	}
-	setUsage(id: number, usage: UsageStats, model?: string): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.usage = { ...usage };
-		if (model) run.model = model;
-		this.notify();
-	}
-
-	appendTranscript(id: number, line: TranscriptLine): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.transcript.push(line);
-		this.notify();
-	}
-
-	/** Append streamed assistant text, merging consecutive deltas into coherent
-	 * lines (split only on real newlines) instead of one line per token fragment. */
-	appendTextDelta(id: number, delta: string): void {
-		const run = this.find(id);
-		if (!run || delta.length === 0) return;
-		const segments = delta.split("\n");
-		for (let i = 0; i < segments.length; i++) {
-			const seg = segments[i];
-			const last = run.transcript[run.transcript.length - 1];
-			if (i === 0 && last && last.kind === "text") {
-				last.text += seg;
-			} else {
-				run.transcript.push({ kind: "text", text: seg });
-			}
-		}
-		this.notify();
-	}
-
-	getRuns(): RunView[] {
-		return this.runs;
-	}
-
-	subscribe(cb: () => void): () => void {
-		this.subscribers.add(cb);
-		return () => {
-			this.subscribers.delete(cb);
-		};
-	}
-
-	summarize(run: RunView): string {
-		const usage = formatUsageCompact(run.usage);
-		const parts = [run.agent];
-		if (run.model) parts.push(run.model);
-		if (usage) parts.push(usage);
-		const elapsed = formatElapsed(run);
-		if (elapsed) parts.push(elapsed);
-		return parts.join(" · ");
-	}
-
-	/** Text of the most recent transcript entry (what the run is doing now). */
-	lastActivity(run: RunView): string | undefined {
-		for (let i = run.transcript.length - 1; i >= 0; i--) {
-			const text = run.transcript[i].text.trim();
-			if (text.length > 0) return text;
-		}
-		return undefined;
-	}
-
-	private find(id: number): RunView | undefined {
-		return this.runs.find((r) => r.id === id);
-	}
-
-	private notify(): void {
-		for (const cb of this.subscribers) {
-			try {
-				cb();
-			} catch {
-				/* subscriber errors must not break the store */
-			}
-		}
-	}
-}
-
-export const monitor = new MonitorStore();
-
-// ---------------------------------------------------------------------------
-// Status icons
-// ---------------------------------------------------------------------------
-
-export function statusIcon(status: RunStatus, theme: Theme): string {
-	switch (status) {
-		case "running":
-			return theme.fg("accent", "●");
-		case "done":
-			return theme.fg("success", "✓");
-		case "failed":
-			return theme.fg("error", "✗");
-		default:
-			return theme.fg("dim", "○");
-	}
-}
-
-/** User-facing status label shown in the widget. */
-export function statusLabel(status: RunStatus): string {
-	switch (status) {
-		case "queued":
-			return "ready";
-		case "running":
-			return "running";
-		case "done":
-			return "done";
-		case "failed":
-			return "stopped";
-	}
-}
-
-/** Theme color matching the status label. */
-export function statusColor(status: RunStatus): "accent" | "success" | "error" | "dim" {
-	switch (status) {
-		case "running":
-			return "accent";
-		case "done":
-			return "success";
-		case "failed":
-			return "error";
-		default:
-			return "dim";
-	}
-}
+/**
+ * Sub-agent monitor: a module-level singleton store that tracks subagent runs
+ * for the current turn.
+ *
+ * The store notifies subscribers on every mutation so the persistent widget
+ * above the editor can re-render. Each run carries timing information
+ * (started/ended) plus a concise activity string describing what the run is
+ * doing right now ("thinking", "read src/index.ts", ...). Runs are removed
+ * as soon as they finish: the tool result is the durable record in the main
+ * conversation, so a stale "done" row must not linger in the widget.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { UsageStats } from "./spawn.ts";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type RunStatus = "queued" | "running" | "done" | "failed";
+
+export interface RunView {
+	id: number;
+	agent: string;
+	model?: string;
+	status: RunStatus;
+	usage: UsageStats;
+	/** Concise current activity ("thinking", "read src/index.ts"); last writer wins. */
+	activity?: string;
+	/** Epoch ms when the run started executing (set on first "running" status). */
+	startedAt?: number;
+	/** Epoch ms when the run finished (set on "done"/"failed"). */
+	endedAt?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+function formatTokens(count: number): string {
+	if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+	if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
+	return String(count);
+}
+
+export function formatUsageCompact(usage: UsageStats): string {
+	const parts: string[] = [];
+	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
+	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
+	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
+	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+	return parts.join(" ");
+}
+
+export function formatDuration(ms: number): string {
+	const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+	if (totalSeconds < 60) return `${totalSeconds}s`;
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (minutes < 60) return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+	const hours = Math.floor(minutes / 60);
+	return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
+}
+
+/** Elapsed wall time of a run: live while running, final once finished. */
+export function formatElapsed(run: RunView, now: number = Date.now()): string {
+	if (run.startedAt === undefined) return "";
+	const end = run.endedAt ?? now;
+	return formatDuration(end - run.startedAt);
+}
+
+/** Max length of the argument target inside a formatted activity line. */
+export const ACTIVITY_TARGET_MAX = 60;
+
+function shortTarget(value: unknown): string {
+	if (typeof value !== "string") return "";
+	const oneLine = value.replace(/\s+/g, " ").trim();
+	// Slice by code point so emoji / CJK-ext never leave a lone surrogate.
+	const chars = [...oneLine];
+	return chars.length > ACTIVITY_TARGET_MAX ? `${chars.slice(0, ACTIVITY_TARGET_MAX - 1).join("")}…` : oneLine;
+}
+
+/** Concise "what is it doing" text for a tool call: the tool name plus its single
+ * most telling argument (path, command, pattern, ...) — never a raw JSON blob. */
+export function formatToolActivity(toolName: string, args: unknown): string {
+	const a = (typeof args === "object" && args !== null ? args : {}) as Record<string, unknown>;
+	const pick = (...keys: string[]): string => {
+		for (const key of keys) {
+			const s = shortTarget(a[key]);
+			if (s) return s;
+		}
+		return "";
+	};
+	let target: string;
+	switch (toolName) {
+		case "bash":
+		case "shell":
+			target = pick("command");
+			break;
+		case "read":
+		case "edit":
+		case "write":
+		case "ls":
+			target = pick("path", "file", "filePath");
+			break;
+		case "grep":
+		case "find":
+		case "glob":
+			target = pick("pattern", "query", "path");
+			break;
+		case "web_search":
+		case "search":
+			target = pick("query");
+			break;
+		case "fetch":
+		case "web_fetch":
+		case "fetch_content":
+			target = pick("url");
+			break;
+		case "subagent":
+			target = pick("agent", "task");
+			break;
+		default:
+			target = pick("path", "command", "query", "pattern", "url", "file", "task");
+	}
+	return target ? `${toolName} ${target}` : toolName;
+}
+
+// ---------------------------------------------------------------------------
+// MonitorStore
+// ---------------------------------------------------------------------------
+
+export class MonitorStore {
+	private runs: RunView[] = [];
+	private nextId = 1;
+	private subscribers = new Set<() => void>();
+
+	beginTurn(): void {
+		// Clear finished runs from a previous turn, but keep any still-active
+		// (queued/running) ones so a concurrent sub-agent call is not wiped.
+		this.runs = this.runs.filter((r) => r.status === "queued" || r.status === "running");
+		this.notify();
+	}
+
+	addRun(agent: string, model?: string): number {
+		const id = this.nextId++;
+		this.runs.push({
+			id,
+			agent,
+			model,
+			status: "queued",
+			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+		});
+		this.notify();
+		return id;
+	}
+
+	setStatus(id: number, status: RunStatus): void {
+		const run = this.find(id);
+		if (!run) return;
+		run.status = status;
+		if (status === "running" && run.startedAt === undefined) {
+			run.startedAt = Date.now();
+		} else if ((status === "done" || status === "failed") && run.endedAt === undefined) {
+			run.endedAt = Date.now();
+		}
+		this.notify();
+	}
+	setUsage(id: number, usage: UsageStats, model?: string): void {
+		const run = this.find(id);
+		if (!run) return;
+		run.usage = { ...usage };
+		if (model) run.model = model;
+		this.notify();
+	}
+
+	/** Update the run's current one-line activity (what it is doing now). */
+	setActivity(id: number, text: string): void {
+		const run = this.find(id);
+		if (!run) return;
+		run.activity = text;
+		this.notify();
+	}
+
+	/** Remove a run (finished runs leave the widget). Returns the removed run. */
+	removeRun(id: number): RunView | undefined {
+		const index = this.runs.findIndex((r) => r.id === id);
+		if (index === -1) return undefined;
+		const [run] = this.runs.splice(index, 1);
+		this.notify();
+		return run;
+	}
+
+	getRuns(): RunView[] {
+		return this.runs;
+	}
+
+	subscribe(cb: () => void): () => void {
+		this.subscribers.add(cb);
+		return () => {
+			this.subscribers.delete(cb);
+		};
+	}
+
+	summarize(run: RunView): string {
+		const usage = formatUsageCompact(run.usage);
+		const parts = [run.agent];
+		if (run.model) parts.push(run.model);
+		if (usage) parts.push(usage);
+		const elapsed = formatElapsed(run);
+		if (elapsed) parts.push(elapsed);
+		return parts.join(" · ");
+	}
+
+	private find(id: number): RunView | undefined {
+		return this.runs.find((r) => r.id === id);
+	}
+
+	private notify(): void {
+		for (const cb of this.subscribers) {
+			try {
+				cb();
+			} catch {
+				/* subscriber errors must not break the store */
+			}
+		}
+	}
+}
+
+export const monitor = new MonitorStore();
+
+// ---------------------------------------------------------------------------
+// Status icons
+// ---------------------------------------------------------------------------
+
+export function statusIcon(status: RunStatus, theme: Theme): string {
+	switch (status) {
+		case "running":
+			return theme.fg("accent", "●");
+		case "done":
+			return theme.fg("success", "✓");
+		case "failed":
+			return theme.fg("error", "✗");
+		default:
+			return theme.fg("dim", "○");
+	}
+}
+
+/** User-facing status label shown in the widget. */
+export function statusLabel(status: RunStatus): string {
+	switch (status) {
+		case "queued":
+			return "ready";
+		case "running":
+			return "running";
+		case "done":
+			return "done";
+		case "failed":
+			return "stopped";
+	}
+}
+
+/** Theme color matching the status label. */
+export function statusColor(status: RunStatus): "accent" | "success" | "error" | "dim" {
+	switch (status) {
+		case "running":
+			return "accent";
+		case "done":
+			return "success";
+		case "failed":
+			return "error";
+		default:
+			return "dim";
+	}
+}