@vitos-pizza/vitos-pizza 0.1.0

package/node_modules/@vitos-pizza/subagents/src/async/spawn-async.ts

@@ -0,0 +1,220 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { executeSubagent, newRunId } from "../execute-subagent.ts";
+import {
+	agentsFromDetails,
+	getAsyncRootFromSessionFile,
+	getRunDir,
+	isTerminalState,
+	readRunResult,
+	readRunStatus,
+	writeRunResult,
+	writeRunStatus,
+} from "./storage.ts";
+import type { SubagentEventBus } from "./job-tracker.ts";
+import { emitAsyncComplete, emitAsyncStarted } from "./job-tracker.ts";
+import type { AsyncJobTracker } from "./job-tracker.ts";
+import {
+	SUBAGENT_CHILD_DISPOSED,
+	SUBAGENT_CHILD_SESSION_CREATED,
+} from "../rpc/channels.ts";
+import type { ExecuteSubagentInput, SubagentDetails, SubagentMode } from "../types.ts";
+import { getResultOutput } from "../utils.ts";
+
+export interface SpawnAsyncInput {
+	params: ExecuteSubagentInput;
+	cwd: string;
+	parentSessionId?: string | null;
+	sessionFile?: string | null;
+	tracker: AsyncJobTracker;
+	events?: SubagentEventBus;
+	signal?: AbortSignal;
+}
+
+export function spawnAsyncRun(input: SpawnAsyncInput): {
+	runId: string;
+	result: AgentToolResult<SubagentDetails>;
+} {
+	const runId = newRunId();
+	const asyncRoot = getAsyncRootFromSessionFile(input.sessionFile ?? null);
+	const runDir = getRunDir(asyncRoot, runId);
+	fs.mkdirSync(runDir, { recursive: true });
+
+	const mode: SubagentMode =
+		(input.params.chain?.length ?? 0) > 0
+			? "chain"
+			: (input.params.tasks?.length ?? 0) > 0
+				? "parallel"
+				: "single";
+
+	const agents =
+		mode === "single" && input.params.agent
+			? [input.params.agent]
+			: mode === "chain"
+				? (input.params.chain?.map((step) => step.agent) ?? [])
+				: (input.params.tasks?.map((task) => task.agent) ?? []);
+
+	const status = {
+		id: runId,
+		state: "queued" as const,
+		mode,
+		sessionId: input.parentSessionId ?? null,
+		createdAt: Date.now(),
+		updatedAt: Date.now(),
+		agents,
+	};
+
+	writeRunStatus(runDir, status);
+	input.tracker.track(runId, status);
+
+	emitAsyncStarted(input.events, {
+		id: runId,
+		mode,
+		sessionId: input.parentSessionId ?? null,
+		agents,
+	});
+
+	input.events?.emit(SUBAGENT_CHILD_SESSION_CREATED, {
+		sessionId: runId,
+		parentSessionId: input.parentSessionId ?? undefined,
+	});
+
+	const childSessionId = randomUUID();
+
+	void executeSubagent(input.params, {
+		cwd: input.cwd,
+		parentSessionId: input.parentSessionId,
+		signal: input.signal,
+	})
+		.then((toolResult) => {
+			const details = toolResult.details;
+			const now = Date.now();
+			const failed =
+				details.results.some((entry) => entry.exitCode !== 0) ||
+				toolResult.content[0]?.type === "text" &&
+					toolResult.content[0].text.includes("failed");
+			const terminalState = failed ? "failed" : "complete";
+			const exitCode = failed ? 1 : 0;
+			const finalOutput =
+				toolResult.content[0]?.type === "text"
+					? toolResult.content[0].text
+					: "(no output)";
+
+			const nextStatus = {
+				...status,
+				state: terminalState as "complete" | "failed",
+				updatedAt: now,
+				exitCode,
+				agents: details ? agentsFromDetails(details) : agents,
+			};
+
+			writeRunStatus(runDir, nextStatus);
+			input.tracker.update(runId, nextStatus);
+
+			if (details) {
+				writeRunResult(runDir, {
+					status: nextStatus,
+					details,
+					finalOutput,
+				});
+			}
+
+			emitAsyncComplete(input.events, { id: runId, exitCode, finalOutput });
+			input.events?.emit(SUBAGENT_CHILD_DISPOSED, { sessionId: childSessionId });
+		})
+		.catch((error: unknown) => {
+			const message = error instanceof Error ? error.message : String(error);
+			const nextStatus = {
+				...status,
+				state: "failed" as const,
+				updatedAt: Date.now(),
+				exitCode: 1,
+				error: message,
+			};
+			writeRunStatus(runDir, nextStatus);
+			input.tracker.update(runId, nextStatus);
+			emitAsyncComplete(input.events, {
+				id: runId,
+				exitCode: 1,
+				finalOutput: message,
+			});
+			input.events?.emit(SUBAGENT_CHILD_DISPOSED, { sessionId: childSessionId });
+		});
+
+	input.tracker.update(runId, { state: "running", updatedAt: Date.now() });
+	writeRunStatus(runDir, { ...status, state: "running", updatedAt: Date.now() });
+
+	return {
+		runId,
+		result: {
+			content: [
+				{
+					type: "text",
+					text: `Async subagent started (id: ${runId}). Use wait({ id: "${runId}" }) or wait() to collect results.`,
+				},
+			],
+			details: {
+				mode,
+				agentScope: input.params.agentScope ?? "both",
+				projectAgentsDir: null,
+				results: [],
+				runId,
+				async: true,
+			},
+		},
+	};
+}
+
+export function restoreAsyncJobs(
+	sessionFile: string | null,
+	tracker: AsyncJobTracker,
+): void {
+	const asyncRoot = getAsyncRootFromSessionFile(sessionFile);
+	for (const runDir of listRunDirs(asyncRoot)) {
+		const status = readRunStatus(runDir);
+		if (!status) continue;
+		if (isTerminalState(status.state)) {
+			tracker.track(status.id, status);
+			continue;
+		}
+		tracker.track(status.id, {
+			...status,
+			state: "failed",
+			exitCode: 1,
+			error: "Session restarted before async run completed.",
+			updatedAt: Date.now(),
+		});
+		writeRunStatus(runDir, tracker.get(status.id)!);
+	}
+}
+
+function listRunDirs(asyncRoot: string): string[] {
+	if (!fs.existsSync(asyncRoot)) return [];
+	try {
+		return fs
+			.readdirSync(asyncRoot, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.map((entry) => getRunDir(asyncRoot, entry.name));
+	} catch {
+		return [];
+	}
+}
+
+export function summarizeAsyncRun(runDir: string) {
+	const status = readRunStatus(runDir);
+	if (!status) return null;
+	const result = readRunResult(runDir);
+	const finalOutput =
+		result?.finalOutput ??
+		(result?.details.results[0]
+			? getResultOutput(result.details.results[0])
+			: undefined);
+	return {
+		id: status.id,
+		state: status.state,
+		agents: status.agents,
+		exitCode: status.exitCode,
+		finalOutput,
+	};
+}

package/node_modules/@vitos-pizza/subagents/src/async/storage.ts

@@ -0,0 +1,57 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { AsyncRunResult, AsyncRunStatus, SubagentDetails } from "../types.ts";
+import { readJsonFile, writeJsonAtomic } from "../utils.ts";
+
+export function getAsyncRootFromSessionFile(sessionFile: string | null): string {
+	if (sessionFile) {
+		const baseName = path.basename(sessionFile, ".jsonl");
+		const sessionsDir = path.dirname(sessionFile);
+		return path.join(sessionsDir, baseName, "subagents", "async");
+	}
+	return path.join(os.tmpdir(), "vitos-subagents-async");
+}
+
+export function getRunDir(asyncRoot: string, runId: string): string {
+	return path.join(asyncRoot, runId);
+}
+
+export function writeRunStatus(runDir: string, status: AsyncRunStatus): void {
+	writeJsonAtomic(path.join(runDir, "status.json"), status);
+}
+
+export function writeRunResult(runDir: string, result: AsyncRunResult): void {
+	writeJsonAtomic(path.join(runDir, "result.json"), result);
+}
+
+export function readRunStatus(runDir: string): AsyncRunStatus | null {
+	return readJsonFile<AsyncRunStatus>(path.join(runDir, "status.json"));
+}
+
+export function readRunResult(runDir: string): AsyncRunResult | null {
+	return readJsonFile<AsyncRunResult>(path.join(runDir, "result.json"));
+}
+
+export function listRunDirs(asyncRoot: string): string[] {
+	if (!fs.existsSync(asyncRoot)) return [];
+	try {
+		return fs
+			.readdirSync(asyncRoot, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.map((entry) => path.join(asyncRoot, entry.name));
+	} catch {
+		return [];
+	}
+}
+
+export function isTerminalState(state: AsyncRunStatus["state"]): boolean {
+	return state === "complete" || state === "failed";
+}
+
+export function agentsFromDetails(details: SubagentDetails): string[] {
+	const names = new Set<string>();
+	for (const result of details.results) names.add(result.agent);
+	if (details.results.length === 0 && details.mode === "single") return [];
+	return Array.from(names);
+}

package/node_modules/@vitos-pizza/subagents/src/env.ts

@@ -0,0 +1,4 @@
+export const SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD";
+export const SUBAGENT_PARENT_SESSION_ENV = "PI_SUBAGENT_PARENT_SESSION";
+export const SUBAGENT_RUN_ID_ENV = "PI_SUBAGENT_RUN_ID";
+export const SUBAGENT_CHILD_AGENT_ENV = "PI_SUBAGENT_CHILD_AGENT";

package/node_modules/@vitos-pizza/subagents/src/execute-subagent.ts

@@ -0,0 +1,285 @@
+import { randomUUID } from "node:crypto";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { discoverAgents } from "./agents.ts";
+import { runSingleAgent } from "./run-agent.ts";
+import type {
+	AgentScope,
+	ExecuteSubagentInput,
+	SubagentDetails,
+	SubagentMode,
+	SingleResult,
+} from "./types.ts";
+import {
+	DEFAULT_CONCURRENCY,
+	getFinalOutput,
+	getResultOutput,
+	isFailedResult,
+	mapWithConcurrencyLimit,
+	MAX_PARALLEL_TASKS,
+	truncateParallelOutput,
+} from "./utils.ts";
+
+export interface ExecuteContext {
+	cwd: string;
+	parentSessionId?: string | null;
+	signal?: AbortSignal;
+	onUpdate?: (details: SubagentDetails, text: string) => void;
+}
+
+function countModes(input: ExecuteSubagentInput): number {
+	return (
+		Number(Boolean(input.chain?.length)) +
+		Number(Boolean(input.tasks?.length)) +
+		Number(Boolean(input.agent && input.task))
+	);
+}
+
+function resolveMode(input: ExecuteSubagentInput): SubagentMode | null {
+	if ((input.chain?.length ?? 0) > 0) return "chain";
+	if ((input.tasks?.length ?? 0) > 0) return "parallel";
+	if (input.agent && input.task) return "single";
+	return null;
+}
+
+export function buildSubagentDetails(
+	mode: SubagentMode,
+	agentScope: AgentScope,
+	projectAgentsDir: string | null,
+	results: SingleResult[],
+	extra?: Partial<SubagentDetails>,
+): SubagentDetails {
+	return {
+		mode,
+		agentScope,
+		projectAgentsDir,
+		results,
+		...extra,
+	};
+}
+
+export async function executeSubagent(
+	input: ExecuteSubagentInput,
+	ctx: ExecuteContext,
+): Promise<AgentToolResult<SubagentDetails>> {
+	const agentScope: AgentScope = input.agentScope ?? "both";
+	const discovery = discoverAgents(ctx.cwd, agentScope);
+	const agents = discovery.agents;
+	const mode = resolveMode(input);
+
+	if (countModes(input) !== 1 || !mode) {
+		const available =
+			agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") ||
+			"none";
+		return {
+			content: [
+				{
+					type: "text",
+					text: `Invalid parameters. Provide exactly one mode.\nAvailable agents: ${available}`,
+				},
+			],
+			details: buildSubagentDetails("single", agentScope, discovery.projectAgentsDir, []),
+		};
+	}
+
+	const makeDetails = (
+		results: SingleResult[],
+		extra?: Partial<SubagentDetails>,
+	) =>
+		buildSubagentDetails(mode, agentScope, discovery.projectAgentsDir, results, extra);
+
+	if (mode === "chain" && input.chain) {
+		const results: SingleResult[] = [];
+		let previousOutput = "";
+
+		for (let i = 0; i < input.chain.length; i++) {
+			const step = input.chain[i];
+			const taskWithContext = step.task.replace(/\{previous\}/g, previousOutput);
+			const result = await runSingleAgent({
+				defaultCwd: ctx.cwd,
+				agents,
+				agentName: step.agent,
+				task: taskWithContext,
+				cwd: step.cwd,
+				step: i + 1,
+				parentSessionId: ctx.parentSessionId,
+				signal: ctx.signal,
+				onUpdate: ctx.onUpdate
+					? (partial) => {
+							ctx.onUpdate?.(makeDetails([...results, partial.result]), partial.content[0]?.text ?? "");
+						}
+					: undefined,
+			});
+			results.push(result);
+
+			if (isFailedResult(result)) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Chain stopped at step ${i + 1} (${step.agent}): ${getResultOutput(result)}`,
+						},
+					],
+					details: makeDetails(results),
+				};
+			}
+			previousOutput = getFinalOutput(result.messages);
+		}
+
+		const last = results[results.length - 1];
+		return {
+			content: [
+				{
+					type: "text",
+					text: getFinalOutput(last.messages) || "(no output)",
+				},
+			],
+			details: makeDetails(results),
+		};
+	}
+
+	if (mode === "parallel" && input.tasks) {
+		if (input.tasks.length > MAX_PARALLEL_TASKS) {
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Too many parallel tasks (${input.tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`,
+					},
+				],
+				details: makeDetails([]),
+			};
+		}
+
+		const concurrency = input.concurrency ?? DEFAULT_CONCURRENCY;
+		const allResults: SingleResult[] = new Array(input.tasks.length);
+		for (let i = 0; i < input.tasks.length; i++) {
+			allResults[i] = {
+				agent: input.tasks[i].agent,
+				agentSource: "unknown",
+				task: input.tasks[i].task,
+				exitCode: -1,
+				messages: [],
+				stderr: "",
+				usage: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					cost: 0,
+					contextTokens: 0,
+					turns: 0,
+				},
+			};
+		}
+
+		const emitParallelUpdate = () => {
+			if (!ctx.onUpdate) return;
+			const running = allResults.filter((result) => result.exitCode === -1).length;
+			const done = allResults.filter((result) => result.exitCode !== -1).length;
+			ctx.onUpdate(
+				makeDetails([...allResults]),
+				`Parallel: ${done}/${allResults.length} done, ${running} running...`,
+			);
+		};
+
+		const results = await mapWithConcurrencyLimit(
+			input.tasks,
+			concurrency,
+			async (task, index) => {
+				const result = await runSingleAgent({
+					defaultCwd: ctx.cwd,
+					agents,
+					agentName: task.agent,
+					task: task.task,
+					cwd: task.cwd,
+					parentSessionId: ctx.parentSessionId,
+					signal: ctx.signal,
+					onUpdate: ctx.onUpdate
+						? (partial) => {
+								allResults[index] = partial.result;
+								emitParallelUpdate();
+							}
+						: undefined,
+				});
+				allResults[index] = result;
+				emitParallelUpdate();
+				return result;
+			},
+		);
+
+		const successCount = results.filter((result) => !isFailedResult(result)).length;
+		const summaries = results.map((result) => {
+			const output = truncateParallelOutput(getResultOutput(result));
+			const status = isFailedResult(result)
+				? `failed${result.stopReason && result.stopReason !== "end" ? ` (${result.stopReason})` : ""}`
+				: "completed";
+			return `### [${result.agent}] ${status}\n\n${output}`;
+		});
+
+		return {
+			content: [
+				{
+					type: "text",
+					text: `Parallel: ${successCount}/${results.length} succeeded\n\n${summaries.join("\n\n---\n\n")}`,
+				},
+			],
+			details: makeDetails(results),
+		};
+	}
+
+	if (mode === "single" && input.agent && input.task) {
+		const result = await runSingleAgent({
+			defaultCwd: ctx.cwd,
+			agents,
+			agentName: input.agent,
+			task: input.task,
+			cwd: input.cwd,
+			parentSessionId: ctx.parentSessionId,
+			signal: ctx.signal,
+			modelOverride: input.model,
+			onUpdate: ctx.onUpdate
+				? (partial) => {
+						ctx.onUpdate?.(makeDetails([partial.result]), partial.content[0]?.text ?? "");
+					}
+				: undefined,
+		});
+
+		if (isFailedResult(result)) {
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Agent ${result.stopReason || "failed"}: ${getResultOutput(result)}`,
+					},
+				],
+				details: makeDetails([result]),
+			};
+		}
+
+		return {
+			content: [
+				{
+					type: "text",
+					text: getFinalOutput(result.messages) || "(no output)",
+				},
+			],
+			details: makeDetails([result]),
+		};
+	}
+
+	const available =
+		agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") || "none";
+	return {
+		content: [
+			{
+				type: "text",
+				text: `Invalid parameters. Available agents: ${available}`,
+			},
+		],
+		details: makeDetails([]),
+	};
+}
+
+export function newRunId(): string {
+	return randomUUID();
+}