@leing2021/super-pi 0.22.0 → 0.23.0

package/extensions/subagent/result-intercom.ts

@@ -1,237 +0,0 @@
-// 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

@@ -1,171 +0,0 @@
-// 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

@@ -1,57 +0,0 @@
-// 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

@@ -1,136 +0,0 @@
-// 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: [] },
-	};
-}