@leing2021/super-pi 0.20.0 → 0.22.0

package/extensions/subagent/result-intercom.ts

@@ -0,0 +1,237 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import { randomUUID } from "node:crypto";
+import {
+	type Details,
+	type IntercomEventBus,
+	type SingleResult,
+	type SubagentResultIntercomChild,
+	type SubagentResultIntercomPayload,
+	type SubagentResultStatus,
+	SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
+	SUBAGENT_RESULT_INTERCOM_EVENT,
+} from "./types.ts";
+
+export function resolveSubagentResultStatus(input: {
+	exitCode?: number;
+	success?: boolean;
+	state?: string;
+	interrupted?: boolean;
+	detached?: boolean;
+}): SubagentResultStatus {
+	if (input.detached) return "detached";
+	if (input.interrupted || input.state === "paused") return "paused";
+	if (typeof input.success === "boolean") return input.success ? "completed" : "failed";
+	if (input.state === "complete") return "completed";
+	if (input.state === "failed") return "failed";
+	if (typeof input.exitCode === "number") return input.exitCode === 0 ? "completed" : "failed";
+	return "failed";
+}
+
+function countStatuses(children: SubagentResultIntercomChild[]): Record<SubagentResultStatus, number> {
+	const counts: Record<SubagentResultStatus, number> = {
+		completed: 0,
+		failed: 0,
+		paused: 0,
+		detached: 0,
+	};
+	for (const child of children) {
+		counts[child.status] += 1;
+	}
+	return counts;
+}
+
+function formatStatusCounts(counts: Record<SubagentResultStatus, number>): string {
+	const parts = [
+		counts.completed ? `${counts.completed} completed` : undefined,
+		counts.failed ? `${counts.failed} failed` : undefined,
+		counts.paused ? `${counts.paused} paused` : undefined,
+		counts.detached ? `${counts.detached} detached` : undefined,
+	].filter((part): part is string => Boolean(part));
+	return parts.length ? parts.join(", ") : "0 results";
+}
+
+function resolveGroupedStatus(children: SubagentResultIntercomChild[]): SubagentResultStatus {
+	const counts = countStatuses(children);
+	if (counts.failed > 0) return "failed";
+	if (counts.paused > 0) return "paused";
+	if (counts.completed > 0) return "completed";
+	if (counts.detached > 0) return "detached";
+	return "failed";
+}
+
+export interface GroupedResultIntercomMessageInput {
+	to: string;
+	runId: string;
+	mode: "single" | "parallel" | "chain";
+	source: "foreground" | "async";
+	children: SubagentResultIntercomChild[];
+	asyncId?: string;
+	asyncDir?: string;
+	chainSteps?: number;
+}
+
+export function formatSubagentResultIntercomMessage(input: {
+	runId: string;
+	mode: "single" | "parallel" | "chain";
+	status: SubagentResultStatus;
+	children: SubagentResultIntercomChild[];
+	asyncId?: string;
+	asyncDir?: string;
+	chainSteps?: number;
+}): string {
+	const counts = countStatuses(input.children);
+	const lines: string[] = [
+		"subagent results",
+		"",
+		`Run: ${input.runId}`,
+		`Mode: ${input.mode}`,
+		`Status: ${input.status}`,
+		`Children: ${formatStatusCounts(counts)}`,
+	];
+	if (input.mode === "chain" && typeof input.chainSteps === "number") {
+		lines.push(`Chain steps: ${input.chainSteps}`);
+	}
+	if (input.asyncId) lines.push(`Async id: ${input.asyncId}`);
+	if (input.asyncDir) lines.push(`Async dir: ${input.asyncDir}`);
+	if (input.children.some((child) => child.intercomTarget)) {
+		lines.push("");
+		lines.push("For clarification, message a listed subagent at its Intercom target.");
+	}
+
+	for (let index = 0; index < input.children.length; index++) {
+		const child = input.children[index]!;
+		lines.push("");
+		lines.push(`${index + 1}. ${child.agent} — ${child.status}`);
+		if (child.intercomTarget) lines.push(`Intercom target: ${child.intercomTarget}`);
+		if (child.artifactPath) lines.push(`Output artifact: ${child.artifactPath}`);
+		if (child.sessionPath) lines.push(`Session: ${child.sessionPath}`);
+		lines.push("Summary:");
+		lines.push(child.summary);
+	}
+
+	return lines.join("\n");
+}
+
+export function buildSubagentResultIntercomPayload(input: GroupedResultIntercomMessageInput): SubagentResultIntercomPayload {
+	const children = input.children.map((child) => ({
+		...child,
+		summary: child.summary.trim() || "(no output)",
+	}));
+	const status = resolveGroupedStatus(children);
+	const summary = formatStatusCounts(countStatuses(children));
+	const firstChild = children[0];
+	const payload: SubagentResultIntercomPayload = {
+		to: input.to,
+		runId: input.runId,
+		mode: input.mode,
+		status,
+		summary,
+		source: input.source,
+		children,
+		...(input.asyncId ? { asyncId: input.asyncId } : {}),
+		...(input.asyncDir ? { asyncDir: input.asyncDir } : {}),
+		...(typeof input.chainSteps === "number" ? { chainSteps: input.chainSteps } : {}),
+		...(firstChild?.agent ? { agent: firstChild.agent } : {}),
+		...(firstChild?.index !== undefined ? { index: firstChild.index } : {}),
+		...(firstChild?.artifactPath ? { artifactPath: firstChild.artifactPath } : {}),
+		...(firstChild?.sessionPath ? { sessionPath: firstChild.sessionPath } : {}),
+		message: "",
+	};
+	payload.message = formatSubagentResultIntercomMessage(payload);
+	return payload;
+}
+
+export async function deliverSubagentResultIntercomEvent(
+	events: IntercomEventBus,
+	payload: SubagentResultIntercomPayload,
+	timeoutMs = 500,
+): Promise<boolean> {
+	if (typeof events.on !== "function" || typeof events.emit !== "function") return false;
+	const requestId = payload.requestId ?? randomUUID();
+	return new Promise((resolve) => {
+		let settled = false;
+		let unsubscribe: (() => void) | undefined;
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const finish = (delivered: boolean) => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			unsubscribe?.();
+			resolve(delivered);
+		};
+		unsubscribe = events.on(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, (data) => {
+			if (!data || typeof data !== "object") return;
+			const delivery = data as { requestId?: unknown; delivered?: unknown };
+			if (delivery.requestId !== requestId) return;
+			finish(delivery.delivered === true);
+		});
+		timer = setTimeout(() => finish(false), timeoutMs);
+		try {
+			events.emit(SUBAGENT_RESULT_INTERCOM_EVENT, { ...payload, requestId });
+		} catch {
+			finish(false);
+		}
+	});
+}
+
+function stripSingleResultOutputs(result: SingleResult): SingleResult {
+	return {
+		...result,
+		messages: undefined,
+		finalOutput: undefined,
+		truncation: undefined,
+	};
+}
+
+export function stripDetailsOutputsForIntercomReceipt(details: Details): Details {
+	return {
+		...details,
+		results: details.results.map(stripSingleResultOutputs),
+	};
+}
+
+export function formatSubagentResultReceipt(input: {
+	mode: "single" | "parallel" | "chain";
+	runId: string;
+	payload: SubagentResultIntercomPayload;
+}): string {
+	const counts = countStatuses(input.payload.children);
+	const modeLabel = input.mode === "single"
+		? "single subagent result"
+		: input.mode === "parallel"
+			? "parallel subagent results"
+			: "chain subagent results";
+	const lines = [
+		`Delivered ${modeLabel} via intercom.`,
+		`Run: ${input.runId}`,
+		`Children: ${formatStatusCounts(counts)}`,
+	];
+
+	const artifacts = input.payload.children.filter((child) => typeof child.artifactPath === "string");
+	if (artifacts.length > 0) {
+		lines.push("Artifacts:");
+		for (const child of artifacts) {
+			lines.push(`- ${child.agent} [${child.status}]: ${child.artifactPath}`);
+		}
+	}
+
+	const intercomTargets = input.payload.children.filter((child) => typeof child.intercomTarget === "string");
+	if (intercomTargets.length > 0) {
+		lines.push("Intercom targets:");
+		for (const child of intercomTargets) {
+			lines.push(`- ${child.agent} [${child.status}]: ${child.intercomTarget}`);
+		}
+	}
+
+	const sessions = input.payload.children.filter((child) => typeof child.sessionPath === "string");
+	if (sessions.length > 0) {
+		lines.push("Sessions:");
+		for (const child of sessions) {
+			lines.push(`- ${child.agent} [${child.status}]: ${child.sessionPath}`);
+		}
+	}
+
+	lines.push("Full grouped output was sent over intercom.");
+	return lines.join("\n");
+}

package/extensions/subagent/result-watcher.ts

@@ -0,0 +1,171 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.ts";
+import { createFileCoalescer } from "./file-coalescer.ts";
+import {
+	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	type SubagentState,
+} from "./types.ts";
+import {
+	buildSubagentResultIntercomPayload,
+	deliverSubagentResultIntercomEvent,
+	resolveSubagentResultStatus,
+} from "./result-intercom.ts";
+
+function isNotFoundError(error: unknown): boolean {
+	return typeof error === "object"
+		&& error !== null
+		&& "code" in error
+		&& (error as NodeJS.ErrnoException).code === "ENOENT";
+}
+
+export function createResultWatcher(
+	pi: ExtensionAPI,
+	state: SubagentState,
+	resultsDir: string,
+	completionTtlMs: number,
+): {
+	startResultWatcher: () => void;
+	primeExistingResults: () => void;
+	stopResultWatcher: () => void;
+} {
+	const handleResult = async (file: string) => {
+		const resultPath = path.join(resultsDir, file);
+		if (!fs.existsSync(resultPath)) return;
+		try {
+			const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as {
+				id?: string;
+				runId?: string;
+				agent?: string;
+				success?: boolean;
+				state?: string;
+				mode?: string;
+				summary?: string;
+				results?: Array<{
+					agent?: string;
+					output?: string;
+					success?: boolean;
+					artifactPaths?: { outputPath?: string };
+					intercomTarget?: string;
+				}>;
+				sessionId?: string;
+				cwd?: string;
+				sessionFile?: string;
+				asyncDir?: string;
+				intercomTarget?: string;
+			};
+			if (data.sessionId && data.sessionId !== state.currentSessionId) return;
+			if (!data.sessionId && data.cwd && data.cwd !== state.baseCwd) return;
+
+			const now = Date.now();
+			const completionKey = buildCompletionKey(data, `result:${file}`);
+			if (markSeenWithTtl(state.completionSeen, completionKey, now, completionTtlMs)) {
+				fs.unlinkSync(resultPath);
+				return;
+			}
+
+			const intercomTarget = data.intercomTarget?.trim();
+			if (intercomTarget) {
+				const childResults = Array.isArray(data.results) && data.results.length > 0
+					? data.results
+					: [{
+						agent: data.agent,
+						output: data.summary,
+						success: data.success,
+					}];
+				const runId = data.runId ?? data.id ?? file.replace(/\.json$/i, "");
+				const mode = data.mode === "single" || data.mode === "parallel" || data.mode === "chain"
+					? data.mode
+					: childResults.length > 1 ? "chain" : "single";
+				const payload = buildSubagentResultIntercomPayload({
+					to: intercomTarget,
+					runId,
+					mode,
+					source: "async",
+					children: childResults.map((result = {}, index) => ({
+						agent: result.agent ?? data.agent ?? `step-${index + 1}`,
+						status: resolveSubagentResultStatus({
+							success: result.success,
+							state: data.state === "paused" || typeof result.success !== "boolean" ? data.state : undefined,
+						}),
+						summary: result.output ?? data.summary ?? "(no output)",
+						index,
+						artifactPath: result.artifactPaths?.outputPath,
+						sessionPath: data.sessionFile,
+						intercomTarget: result.intercomTarget,
+					})),
+					asyncId: data.id,
+					asyncDir: data.asyncDir,
+				});
+				const delivered = await deliverSubagentResultIntercomEvent(pi.events, payload);
+				if (!delivered) {
+					console.error(`Subagent async grouped result intercom delivery was not acknowledged for '${resultPath}'.`);
+				}
+			}
+
+			pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, data);
+			fs.unlinkSync(resultPath);
+		} catch (error) {
+			if (isNotFoundError(error)) return;
+			console.error(`Failed to process subagent result file '${resultPath}':`, error);
+		}
+	};
+
+	state.resultFileCoalescer = createFileCoalescer((file) => {
+		void handleResult(file);
+	}, 50);
+
+	const scheduleRestart = () => {
+		state.watcherRestartTimer = setTimeout(() => {
+			try {
+				fs.mkdirSync(resultsDir, { recursive: true });
+				startResultWatcher();
+			} catch (error) {
+				console.error(`Failed to restart subagent result watcher for '${resultsDir}':`, error);
+			}
+		}, 3000);
+	};
+
+	const startResultWatcher = () => {
+		state.watcherRestartTimer = null;
+		try {
+			state.watcher = fs.watch(resultsDir, (ev, file) => {
+				if (ev !== "rename" || !file) return;
+				const fileName = file.toString();
+				if (!fileName.endsWith(".json")) return;
+				state.resultFileCoalescer.schedule(fileName);
+			});
+			state.watcher.on("error", (error) => {
+				console.error(`Subagent result watcher failed for '${resultsDir}':`, error);
+				state.watcher = null;
+				scheduleRestart();
+			});
+			state.watcher.unref?.();
+		} catch (error) {
+			console.error(`Failed to start subagent result watcher for '${resultsDir}':`, error);
+			state.watcher = null;
+			scheduleRestart();
+		}
+	};
+
+	const primeExistingResults = () => {
+		fs.readdirSync(resultsDir)
+			.filter((f) => f.endsWith(".json"))
+			.forEach((file) => state.resultFileCoalescer.schedule(file, 0));
+	};
+
+	const stopResultWatcher = () => {
+		state.watcher?.close();
+		state.watcher = null;
+		if (state.watcherRestartTimer) {
+			clearTimeout(state.watcherRestartTimer);
+		}
+		state.watcherRestartTimer = null;
+		state.resultFileCoalescer.clear();
+	};
+
+	return { startResultWatcher, primeExistingResults, stopResultWatcher };
+}

package/extensions/subagent/run-history.ts

@@ -0,0 +1,57 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface RunEntry {
+	agent: string;
+	task: string;
+	ts: number;
+	status: "ok" | "error";
+	duration: number;
+	exit?: number;
+}
+
+const HISTORY_PATH = path.join(os.homedir(), ".pi", "agent", "run-history.jsonl");
+const ROTATE_READ_THRESHOLD = 1200;
+const ROTATE_KEEP = 1000;
+
+export function recordRun(agent: string, task: string, exitCode: number, durationMs: number): void {
+	try {
+		const entry: RunEntry = {
+			agent,
+			task: task.slice(0, 200),
+			ts: Math.floor(Date.now() / 1000),
+			status: exitCode === 0 ? "ok" : "error",
+			duration: durationMs,
+			...(exitCode !== 0 ? { exit: exitCode } : {}),
+		};
+		fs.mkdirSync(path.dirname(HISTORY_PATH), { recursive: true });
+		fs.appendFileSync(HISTORY_PATH, `${JSON.stringify(entry)}\n`);
+	} catch {
+		// Best-effort — never crash the execution flow for history recording
+	}
+}
+
+export function loadRunsForAgent(agent: string): RunEntry[] {
+	if (!fs.existsSync(HISTORY_PATH)) return [];
+	let raw: string;
+	try {
+		raw = fs.readFileSync(HISTORY_PATH, "utf-8");
+	} catch {
+		return [];
+	}
+
+	let lines = raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+
+	if (lines.length > ROTATE_READ_THRESHOLD) {
+		lines = lines.slice(-ROTATE_KEEP);
+		try { fs.writeFileSync(HISTORY_PATH, `${lines.join("\n")}\n`, "utf-8"); } catch {}
+	}
+
+	return lines
+		.map((line) => { try { return JSON.parse(line) as RunEntry; } catch { return undefined; } })
+		.filter((entry): entry is RunEntry => Boolean(entry) && entry.agent === agent)
+		.reverse();
+}

package/extensions/subagent/run-status.ts

@@ -0,0 +1,136 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import { formatAsyncRunList, listAsyncRuns } from "./async-status.ts";
+import { ASYNC_DIR, RESULTS_DIR, type Details } from "./types.ts";
+import { findByPrefix, readStatus } from "./utils.ts";
+
+export interface RunStatusParams {
+	action?: "status";
+	id?: string;
+	runId?: string;
+	dir?: string;
+}
+
+function activityText(activityState: unknown, lastActivityAt: unknown): string | undefined {
+	if (typeof lastActivityAt !== "number") return undefined;
+	const seconds = Math.floor(Math.max(0, Date.now() - lastActivityAt) / 1000);
+	return activityState === "needs_attention" ? `no activity for ${seconds}s` : `active ${seconds}s ago`;
+}
+
+export function inspectSubagentStatus(params: RunStatusParams): AgentToolResult<Details> {
+	if (!params.id && !params.runId && !params.dir) {
+		try {
+			const runs = listAsyncRuns(ASYNC_DIR, { states: ["queued", "running"] });
+			return {
+				content: [{ type: "text", text: formatAsyncRunList(runs) }],
+				details: { mode: "single", results: [] },
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text", text: message }],
+				isError: true,
+				details: { mode: "single", results: [] },
+			};
+		}
+	}
+
+	let asyncDir: string | null = null;
+	let resolvedId = params.id ?? params.runId;
+
+	if (params.dir) {
+		asyncDir = path.resolve(params.dir);
+	} else if (resolvedId) {
+		const direct = path.join(ASYNC_DIR, resolvedId);
+		if (fs.existsSync(direct)) {
+			asyncDir = direct;
+		} else {
+			const match = findByPrefix(ASYNC_DIR, resolvedId);
+			if (match) {
+				asyncDir = match;
+				resolvedId = path.basename(match);
+			}
+		}
+	}
+
+	const resultPath = resolvedId && !asyncDir ? findByPrefix(RESULTS_DIR, resolvedId, ".json") : null;
+
+	if (!asyncDir && !resultPath) {
+		return {
+			content: [{ type: "text", text: "Async run not found. Provide id or dir." }],
+			isError: true,
+			details: { mode: "single", results: [] },
+		};
+	}
+
+	if (asyncDir) {
+		let status;
+		try {
+			status = readStatus(asyncDir);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text", text: message }],
+				isError: true,
+				details: { mode: "single", results: [] },
+			};
+		}
+		const logPath = path.join(asyncDir, `subagent-log-${resolvedId ?? "unknown"}.md`);
+		const eventsPath = path.join(asyncDir, "events.jsonl");
+		if (status) {
+			const stepsTotal = status.steps?.length ?? 1;
+			const current = status.currentStep !== undefined ? status.currentStep + 1 : undefined;
+			const stepLine = current !== undefined ? `Step: ${current}/${stepsTotal}` : `Steps: ${stepsTotal}`;
+			const started = new Date(status.startedAt).toISOString();
+			const updated = status.lastUpdate ? new Date(status.lastUpdate).toISOString() : "n/a";
+			const statusActivityText = status.state === "running" ? activityText(status.activityState, status.lastActivityAt) : undefined;
+
+			const lines = [
+				`Run: ${status.runId}`,
+				`State: ${status.state}`,
+				statusActivityText ? `Activity: ${statusActivityText}` : undefined,
+				`Mode: ${status.mode}`,
+				stepLine,
+				`Started: ${started}`,
+				`Updated: ${updated}`,
+				`Dir: ${asyncDir}`,
+			].filter((line): line is string => Boolean(line));
+			for (const [index, step] of (status.steps ?? []).entries()) {
+				const stepActivityText = step.status === "running" ? activityText(step.activityState, step.lastActivityAt) : undefined;
+				lines.push(`Step ${index + 1}: ${step.agent} ${step.status}${stepActivityText ? `, ${stepActivityText}` : ""}`);
+			}
+			if (status.sessionFile) lines.push(`Session: ${status.sessionFile}`);
+			if (fs.existsSync(logPath)) lines.push(`Log: ${logPath}`);
+			if (fs.existsSync(eventsPath)) lines.push(`Events: ${eventsPath}`);
+
+			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [] } };
+		}
+	}
+
+	if (resultPath) {
+		try {
+			const raw = fs.readFileSync(resultPath, "utf-8");
+			const data = JSON.parse(raw) as { id?: string; success?: boolean; summary?: string; exitCode?: number; state?: string };
+			const status = data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
+			const lines = [`Run: ${data.id ?? resolvedId}`, `State: ${status}`, `Result: ${resultPath}`];
+			if (data.summary) lines.push("", data.summary);
+			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [] } };
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text", text: `Failed to read async result file: ${message}` }],
+				isError: true,
+				details: { mode: "single", results: [] },
+			};
+		}
+	}
+
+	return {
+		content: [{ type: "text", text: "Status file not found." }],
+		isError: true,
+		details: { mode: "single", results: [] },
+	};
+}