pi-ui-extend 0.1.1

package/external/pi-tools-suite/src/async-subagents/render.ts

@@ -0,0 +1,230 @@
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { AgentState } from "./lib.js";
+import { modelName, plural, statusGlyph, statusLabel } from "./format.js";
+import type { AgentTaskPreview, SubagentRunRenderDetails } from "./types.js";
+
+interface Component {
+	invalidate(): void;
+	render(width: number): string[];
+}
+
+function statusColor(status: AgentState["status"]): string {
+	if (status === "done") return "success";
+	if (status === "failed" || status === "stopped") return "error";
+	if (status === "running") return "warning";
+	return "dim";
+}
+
+function statusVerb(status: AgentState["status"]): string {
+	if (status === "done") return "Completed";
+	if (status === "failed") return "Failed";
+	if (status === "stopped") return "Stopped";
+	if (status === "running") return "Started";
+	return "Planned";
+}
+
+function statusSummary(agents: AgentState[], theme: any): string {
+	const running = agents.filter((agent) => agent.status === "running").length;
+	const done = agents.filter((agent) => agent.status === "done").length;
+	const failed = agents.filter((agent) => agent.status === "failed" || agent.status === "stopped").length;
+	const planned = agents.filter((agent) => agent.status === "planned").length;
+	const summary: string[] = [];
+	if (running) summary.push(theme.fg("warning", `${running} running`));
+	if (done) summary.push(theme.fg("success", `${done} done`));
+	if (failed) summary.push(theme.fg("error", `${failed} failed`));
+	if (planned) summary.push(theme.fg("dim", `${planned} planned`));
+	return summary.length ? theme.fg("dim", " · ") + summary.join(theme.fg("dim", ", ")) : "";
+}
+
+function appendDetailLine(text: string, prefix: string, line: string, theme: any): string {
+	return text + `\n${theme.fg("dim", prefix + line)}`;
+}
+
+function outputLineSummary(agent: AgentState): string | undefined {
+	const outputLines = (agent.resultLines ?? 0) + (agent.stderrLines ?? 0);
+	if (outputLines > 0) return `${plural(outputLines, "output line")}`;
+	if (agent.eventLines !== undefined) return `${plural(agent.eventLines, "event line")}`;
+	return undefined;
+}
+
+function elapsedSummary(agent: AgentState): string | undefined {
+	if (!agent.startedAt) return undefined;
+	const start = Date.parse(agent.startedAt);
+	if (!Number.isFinite(start)) return undefined;
+	const end = agent.finishedAt ? Date.parse(agent.finishedAt) : Date.now();
+	if (!Number.isFinite(end) || end < start) return undefined;
+	const totalSeconds = Math.floor((end - start) / 1000);
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+
+function commandVerbForMode(mode: SubagentRunRenderDetails["mode"]): string {
+	if (mode === "spawn") return "Started";
+	if (mode === "status") return "Checked";
+	if (mode === "completion") return "Completed";
+	return "Ran";
+}
+
+const SPAWN_PROMPT_COMPACT_TOTAL_LINE_LIMIT = 6;
+
+function findTaskPreview(details: SubagentRunRenderDetails, agentId: string): AgentTaskPreview | undefined {
+	return details.tasks?.find((task) => task.id === agentId);
+}
+
+class SubagentRunComponent implements Component {
+	constructor(
+		private details: SubagentRunRenderDetails,
+		private options: { expanded?: boolean; isPartial?: boolean },
+		private theme: any,
+	) {}
+
+	invalidate(): void {
+		// Stateless; rebuilt on each render width.
+	}
+
+	render(width: number): string[] {
+		return renderSubagentRunText(this.details, this.options, this.theme, width)
+			.split("\n")
+			.map((line) => truncateToWidth(line, width));
+	}
+}
+
+class SubagentSpawnPromptComponent implements Component {
+	constructor(
+		private details: SubagentRunRenderDetails,
+		private options: { expanded?: boolean; isPartial?: boolean },
+		private theme: any,
+	) {}
+
+	invalidate(): void {
+		// Stateless; rebuilt on each render width.
+	}
+
+	render(width: number): string[] {
+		return renderSubagentSpawnPromptsText(this.details, this.options, this.theme, width)
+			.split("\n")
+			.map((line) => truncateToWidth(line, width));
+	}
+}
+
+function renderSubagentRunText(details: SubagentRunRenderDetails, options: { expanded?: boolean; isPartial?: boolean }, theme: any, width: number): string {
+	const agents = details.agents ?? [];
+	const verb = commandVerbForMode(details.mode);
+	let text = theme.fg("toolTitle", theme.bold(`${verb} ${plural(agents.length, "subagent")}, tracked 1 run`));
+	text += statusSummary(agents, theme);
+
+	const visibleAgents = options.expanded ? agents : agents.slice(0, 6);
+	for (const [index, agent] of visibleAgents.entries()) {
+		const isLastVisible = index === visibleAgents.length - 1 && (options.expanded || visibleAgents.length === agents.length);
+		const branch = isLastVisible ? "└" : "├";
+		const detailPrefix = isLastVisible ? "    " : "│   ";
+		const preview = findTaskPreview(details, agent.id);
+		const outputLines = outputLineSummary(agent);
+		const elapsed = elapsedSummary(agent);
+		const model = preview?.model ? modelName(preview.model) : undefined;
+		const showElapsed = Boolean(elapsed && (options.expanded || agent.status === "running"));
+		const prefixParts: string[] = [];
+		prefixParts.push(theme.fg(statusColor(agent.status), statusGlyph(agent.status)));
+		prefixParts.push(theme.fg("accent", agent.id));
+		if (model) prefixParts.push(theme.fg("success", model));
+		const suffixParts: string[] = [];
+		if (outputLines) suffixParts.push(theme.fg("dim", `· ${outputLines}`));
+		if (showElapsed) suffixParts.push(theme.fg("dim", `· ${elapsed}`));
+
+		const parts: string[] = [...prefixParts];
+		if (preview?.task) {
+			const prefix = `${theme.fg("dim", branch)} ${prefixParts.join(" ")} `;
+			const suffix = suffixParts.length ? ` ${suffixParts.join(" ")}` : "";
+			const taskWidth = Math.max(1, width - visibleWidth(prefix) - visibleWidth(suffix));
+			const task = truncateToWidth(preview.task, taskWidth);
+			parts.push(theme.fg("dim", task));
+		}
+		parts.push(...suffixParts);
+		text += `\n${theme.fg("dim", branch)} ${parts.join(" ")}`;
+
+		if (options.expanded) {
+			if (agent.pid) text = appendDetailLine(text, detailPrefix, `pid ${agent.pid}`, theme);
+			if (agent.exitCode !== undefined) text = appendDetailLine(text, detailPrefix, `exit ${agent.exitCode}`, theme);
+			if (preview?.scope) text = appendDetailLine(text, detailPrefix, `scope ${preview.scope}`, theme);
+			if (agent.startedAt) text = appendDetailLine(text, detailPrefix, `started ${agent.startedAt}`, theme);
+			if (agent.finishedAt) text = appendDetailLine(text, detailPrefix, `finished ${agent.finishedAt}`, theme);
+		}
+	}
+
+	if (!options.expanded && agents.length > visibleAgents.length) {
+		text += `\n${theme.fg("dim", "└")} ${theme.fg("muted", `… +${agents.length - visibleAgents.length} more`)}`;
+	}
+
+	if (options.expanded) {
+		text += `\n${theme.fg("dim", `run ${details.runDir}`)}`;
+	} else {
+		text += `\n${theme.fg("dim", "ctrl+o to expand")}`;
+	}
+
+	return text;
+}
+
+export function renderSubagentRun(details: SubagentRunRenderDetails, options: { expanded?: boolean; isPartial?: boolean }, theme: any): Component {
+	return new SubagentRunComponent(details, options, theme);
+}
+
+function spawnPromptCount(details: SubagentRunRenderDetails): number {
+	return details.tasks?.length ?? details.agents?.length ?? 0;
+}
+
+function renderSubagentSpawnPromptsText(details: SubagentRunRenderDetails, options: { expanded?: boolean; isPartial?: boolean }, theme: any, width: number): string {
+	const tasks = details.tasks ?? [];
+	const count = spawnPromptCount(details);
+	let text = theme.fg("toolTitle", theme.bold(renderSpawnChatSummary(details)));
+
+	const compactPromptLineLimit = Math.max(0, SPAWN_PROMPT_COMPACT_TOTAL_LINE_LIMIT - 1);
+	const promptLineLimit = options.expanded ? tasks.length : Math.min(tasks.length, compactPromptLineLimit);
+	const visibleTasks = tasks.slice(0, promptLineLimit);
+	const hiddenTasks = tasks.length - visibleTasks.length;
+	const lines: string[] = [];
+	for (const [index, task] of visibleTasks.entries()) {
+		const isOverflowSummary = !options.expanded && hiddenTasks > 0 && index === compactPromptLineLimit - 1;
+		const isLastVisible = index === visibleTasks.length - 1;
+		const branch = isLastVisible ? "└" : "├";
+		if (isOverflowSummary) {
+			lines.push(`${theme.fg("dim", branch)} ${theme.fg("muted", `… +${hiddenTasks + 1} more prompts`)}`);
+			break;
+		}
+
+		const prefix = `${theme.fg("dim", branch)} ${theme.fg("accent", `${task.id}:`)} `;
+		const suffix = task.model ? ` ${theme.fg("success", modelName(task.model))}` : "";
+		const promptWidth = Math.max(1, width - visibleWidth(prefix) - visibleWidth(suffix));
+		const prompt = truncateToWidth(task.task ?? "(prompt unavailable)", promptWidth);
+		lines.push(`${prefix}${theme.fg("dim", prompt)}${suffix}`);
+	}
+
+	if (lines.length === 0 && count > 0) {
+		text += `\n${theme.fg("dim", `Prompts unavailable for ${plural(count, "subagent")}.`)}`;
+	} else if (lines.length > 0) {
+		text += `\n${lines.join("\n")}`;
+	}
+
+	return text;
+}
+
+export function renderSubagentSpawnPrompts(details: SubagentRunRenderDetails, options: { expanded?: boolean; isPartial?: boolean }, theme: any): Component {
+	return new SubagentSpawnPromptComponent(details, options, theme);
+}
+
+export function renderPlainRunSummary(details: SubagentRunRenderDetails): string {
+	const agents = details.agents ?? [];
+	const verb = commandVerbForMode(details.mode);
+	const lines = [`${verb} ${plural(agents.length, "subagent")}, tracked 1 run`];
+	for (const agent of agents) {
+		const outputLines = outputLineSummary(agent);
+		lines.push(
+			`${statusGlyph(agent.status)} ${statusVerb(agent.status)} ${agent.id} -> ${statusLabel(agent.status)}${outputLines ? ` · ${outputLines}` : ""}`,
+		);
+	}
+	return lines.join("\n");
+}
+
+export function renderSpawnChatSummary(details: SubagentRunRenderDetails): string {
+	return `Started ${plural(spawnPromptCount(details), "subagent")}.`;
+}

package/external/pi-tools-suite/src/async-subagents/subagent-overlay.ts

@@ -0,0 +1,77 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getRunState, listRunDirs, readParentSessionLink, type AgentState } from "./lib.js";
+import { getLiveRun } from "./live.js";
+import type { LiveAgent } from "./types.js";
+
+/**
+ * Tracks live sub-agents for the event system. TUI widget rendering has been
+ * removed — extensions should not render custom TUI components.
+ */
+export class SubagentOverlay {
+	constructor(private liveAgents: Map<string, Map<string, LiveAgent>>) {}
+
+	restoreRunningAgents(cwd: string, parentSession?: string): void {
+		for (const runDir of listRunDirs(cwd)) {
+			const running = getRunState(runDir, undefined, {
+				includeLineCounts: false,
+				checkRpcPromptFailure: false,
+			}).agents.filter((agent) => agent.status === "running");
+			if (running.length === 0) continue;
+			const liveRun = getLiveRun(this.liveAgents, runDir);
+			for (const agent of running) {
+				if (liveRun.has(agent.id)) continue;
+				const agentDir = path.join(runDir, agent.id);
+				const agentParentSession = readParentSessionLink(agentDir);
+				if (parentSession && agentParentSession && !pathsEqual(parentSession, agentParentSession)) continue;
+				liveRun.set(agent.id, { runDir, agentId: agent.id, parentSession: agentParentSession, completed: Promise.resolve() });
+			}
+			if (liveRun.size === 0) this.liveAgents.delete(runDir);
+		}
+	}
+
+	update(): void {
+		// Prune completed agents from liveAgents, but do not render any UI.
+		for (const [runDir, liveRun] of [...this.liveAgents.entries()]) {
+			const ids = [...liveRun.keys()];
+			const states = new Map(
+				getRunState(runDir, ids, {
+					includeLineCounts: false,
+					checkRpcPromptFailure: false,
+				}).agents.map((agent) => [agent.id, agent]),
+			);
+
+			for (const [agentId] of [...liveRun.entries()]) {
+				const agent = states.get(agentId);
+				if (!agent || isTerminalStatus(agent.status)) {
+					liveRun.delete(agentId);
+					continue;
+				}
+			}
+
+			if (liveRun.size === 0) this.liveAgents.delete(runDir);
+		}
+	}
+
+	dispose(): void {
+		// No UI state to clean up.
+	}
+}
+
+function isTerminalStatus(status: AgentState["status"]): boolean {
+	return status === "done" || status === "failed" || status === "stopped";
+}
+
+
+function pathsEqual(left: string, right: string): boolean {
+	return normalizePath(left) === normalizePath(right);
+}
+
+function normalizePath(filePath: string): string {
+	const resolved = path.resolve(filePath);
+	try {
+		return fs.realpathSync.native(resolved);
+	} catch {
+		return resolved;
+	}
+}

package/external/pi-tools-suite/src/async-subagents/tasks.ts

@@ -0,0 +1,120 @@
+import type { AgentTask } from "./lib.js";
+import { validateBasename } from "./lib.js";
+import { truncate } from "./format.js";
+import type { AgentTaskPreview } from "./types.js";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function optionalString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function optionalPositiveNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+function optionalTimeoutMs(item: Record<string, unknown>): number | undefined {
+	const timeoutMs = optionalPositiveNumber(item.timeoutMs);
+	if (timeoutMs !== undefined) return Math.max(1, Math.round(timeoutMs));
+	const timeoutSeconds = optionalPositiveNumber(item.timeoutSeconds);
+	if (timeoutSeconds !== undefined) return Math.max(1, Math.round(timeoutSeconds * 1000));
+	return undefined;
+}
+
+function nextGeneratedAgentId(seenIds: Set<string>, reservedIds: Set<string>): string {
+	let index = 1;
+	while (true) {
+		const id = `agent-${index}`;
+		if (!seenIds.has(id) && !reservedIds.has(id)) return id;
+		index++;
+	}
+}
+
+export function normalizeAgentTasks(input: unknown): { tasks: AgentTask[]; error?: undefined } | { tasks?: undefined; error: string } {
+	if (!Array.isArray(input) || input.length === 0) {
+		return { error: "spawn requires at least one task in the tasks array." };
+	}
+
+	const reservedIds = new Set<string>();
+	for (const item of input) {
+		if (!isRecord(item)) continue;
+		const id = optionalString(item.id);
+		if (id) reservedIds.add(id);
+	}
+
+	const tasks: AgentTask[] = [];
+	const seenIds = new Set<string>();
+	for (let index = 0; index < input.length; index++) {
+		const item = input[index];
+		if (!isRecord(item)) {
+			return { error: `Task ${index + 1} must be an object.` };
+		}
+
+		const taskText = optionalString(item.task);
+		if (!taskText) {
+			return { error: `Task ${index + 1} is missing a non-empty task description.` };
+		}
+
+		const id = optionalString(item.id) ?? nextGeneratedAgentId(seenIds, reservedIds);
+		if (seenIds.has(id)) {
+			return { error: `Duplicate agent ID: "${id}". Each agent must have a unique ID.` };
+		}
+
+		try {
+			validateBasename(id, `tasks[${index}].id`);
+		} catch (error) {
+			return { error: error instanceof Error ? error.message : String(error) };
+		}
+
+		const tools = Array.isArray(item.tools)
+			? item.tools.filter((tool): tool is string => typeof tool === "string" && tool.trim().length > 0)
+			: undefined;
+		const extraArgs = Array.isArray(item.extraArgs)
+			? item.extraArgs.filter((arg): arg is string => typeof arg === "string" && arg.trim().length > 0)
+			: undefined;
+		const scope = optionalString(item.scope);
+		const subagentType = optionalString(item.subagentType) ?? optionalString(item.type);
+		const model = optionalString(item.model);
+		const thinking = optionalString(item.thinking);
+		const promptAppend = optionalString(item.promptAppend);
+		const promptOverride = optionalString(item.promptOverride);
+		const focus = optionalString(item.focus) ?? optionalString(item.attention);
+		const imagePaths = Array.isArray(item.imagePaths)
+			? item.imagePaths.filter((imagePath): imagePath is string => typeof imagePath === "string" && imagePath.trim().length > 0).map((imagePath) => imagePath.trim())
+			: undefined;
+		const timeoutMs = optionalTimeoutMs(item);
+		const parentObjective = optionalString(item.parentObjective);
+
+		seenIds.add(id);
+		const normalizedTask: AgentTask = {
+			id,
+			task: taskText,
+		};
+		if (scope) normalizedTask.scope = scope;
+		if (subagentType) normalizedTask.subagentType = subagentType;
+		if (model) normalizedTask.model = model;
+		if (thinking) normalizedTask.thinking = thinking;
+		if (promptAppend) normalizedTask.promptAppend = promptAppend;
+		if (promptOverride) normalizedTask.promptOverride = promptOverride;
+		if (focus) normalizedTask.focus = focus;
+		if (imagePaths && imagePaths.length > 0) normalizedTask.imagePaths = imagePaths;
+		if (tools && tools.length > 0) normalizedTask.tools = tools;
+		if (extraArgs && extraArgs.length > 0) normalizedTask.extraArgs = extraArgs;
+		if (timeoutMs !== undefined) normalizedTask.timeoutMs = timeoutMs;
+		if (parentObjective) normalizedTask.parentObjective = parentObjective;
+		tasks.push(normalizedTask);
+	}
+
+	return { tasks };
+}
+
+export function toTaskPreviews(tasks: AgentTask[]): AgentTaskPreview[] {
+	return tasks.map((task) => ({
+		id: task.id,
+		task: task.task,
+		scope: task.scope ? truncate(task.scope, 80) : undefined,
+		model: task.model,
+	}));
+}

package/external/pi-tools-suite/src/async-subagents/tools/cleanup.ts

@@ -0,0 +1,99 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@mariozechner/pi-ai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ASYNC_SUBAGENT_TOOL_DESCRIPTIONS } from "../../tool-descriptions.js";
+import { deleteCleanupCandidates, findCleanupCandidates, getRunRoot, removeSubagentRunsFromRegistry, resolveRunDir } from "../lib.js";
+
+export function registerCleanupTool(pi: ExtensionAPI): void {
+	pi.registerTool({
+		...ASYNC_SUBAGENT_TOOL_DESCRIPTIONS.cleanupAction,
+		parameters: Type.Object({
+			runRoot: Type.Optional(Type.String({ description: "Root directory (default: .pi/subagents)" })),
+			days: Type.Optional(Type.Number({ description: "Remove runs older than N days (default 7)", default: 7 })),
+			keep: Type.Optional(Type.Number({ description: "Always keep newest N runs (default 20)", default: 20 })),
+			delete: Type.Optional(Type.Boolean({ description: "Actually delete (default: dry-run)", default: false })),
+		}),
+
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const expectedRoot = getRunRoot(ctx.cwd);
+			const runRoot = params.runRoot
+				? resolveRunDir(ctx.cwd, params.runRoot)
+				: expectedRoot;
+
+			let canonicalExpected: string;
+			try {
+				fs.mkdirSync(expectedRoot, { recursive: true });
+				canonicalExpected = fs.realpathSync(expectedRoot);
+			} catch {
+				return {
+					content: [{ type: "text", text: `Could not create or resolve run root: ${expectedRoot}` }],
+					details: {},
+					isError: true,
+				};
+			}
+
+			let canonicalRunRoot: string;
+			try {
+				canonicalRunRoot = fs.realpathSync(runRoot);
+			} catch {
+				return {
+					content: [{ type: "text", text: `Run root does not exist: ${runRoot}` }],
+					details: {},
+				};
+			}
+
+			if (!canonicalRunRoot.startsWith(canonicalExpected + path.sep) && canonicalRunRoot !== canonicalExpected) {
+				return {
+					content: [{ type: "text", text: `Refusing to delete outside ${canonicalExpected}. Got: ${canonicalRunRoot}` }],
+					details: {},
+					isError: true,
+				};
+			}
+
+			const days = params.days ?? 7;
+			const keep = params.keep ?? 20;
+			const doDelete = params.delete ?? false;
+
+			const candidates = findCleanupCandidates(runRoot, days, keep);
+
+			if (candidates.length === 0) {
+				return {
+					content: [{ type: "text", text: `No cleanup candidates in ${runRoot} (days>${days}, keep newest ${keep}).` }],
+					details: { candidates, deleted: false },
+				};
+			}
+
+			if (!doDelete) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: [
+								`Dry run. Would delete ${candidates.length} completed run(s):`,
+								...candidates.map((c) => `  ${c}`),
+								"",
+								"Pass delete=true to actually remove.",
+							].join("\n"),
+						},
+					],
+					details: { candidates, deleted: false },
+				};
+			}
+
+
+			deleteCleanupCandidates(candidates);
+			removeSubagentRunsFromRegistry(ctx.cwd, candidates);
+
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Deleted ${candidates.length} completed run(s):\n${candidates.map((c) => `  ${c}`).join("\n")}`,
+					},
+				],
+				details: { candidates, deleted: true },
+			};
+		},
+	});
+}