@vitos-pizza/vitos-pizza 0.1.0 → 0.3.0

package/node_modules/@vitos-pizza/subagents/src/run-agent.ts

@@ -1,313 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { Message } from "@earendil-works/pi-ai";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import {
-	applyThinkingSuffix,
-	type AgentConfig,
-} from "./agents.ts";
-import {
-	SUBAGENT_CHILD_AGENT_ENV,
-	SUBAGENT_CHILD_ENV,
-	SUBAGENT_PARENT_SESSION_ENV,
-	SUBAGENT_RUN_ID_ENV,
-} from "./env.ts";
-import { getPiSpawnCommand } from "./spawn.ts";
-import {
-	deriveProgress,
-	toProgressSummary,
-} from "./progress.ts";
-import type { SingleResult } from "./types.ts";
-import { emptyUsage, isFailedResult } from "./utils.ts";
-
-export type OnUpdateCallback = (partial: {
-	content: Array<{ type: "text"; text: string }>;
-	result: SingleResult;
-}) => void;
-
-export interface RunSingleAgentInput {
-	defaultCwd: string;
-	agents: AgentConfig[];
-	agentName: string;
-	task: string;
-	cwd?: string;
-	step?: number;
-	parentSessionId?: string | null;
-	runId?: string;
-	signal?: AbortSignal;
-	onUpdate?: OnUpdateCallback;
-	modelOverride?: string;
-}
-
-async function writePromptToTempFile(
-	agentName: string,
-	prompt: string,
-): Promise<{ dir: string; filePath: string }> {
-	const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "vitos-subagent-"));
-	const safeName = agentName.replace(/[^\w.-]+/g, "_");
-	const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
-	await withFileMutationQueue(filePath, async () => {
-		await fs.promises.writeFile(filePath, prompt, {
-			encoding: "utf-8",
-			mode: 0o600,
-		});
-	});
-	return { dir: tmpDir, filePath };
-}
-
-export async function runSingleAgent(
-	input: RunSingleAgentInput,
-): Promise<SingleResult> {
-	const {
-		defaultCwd,
-		agents,
-		agentName,
-		task,
-		cwd,
-		step,
-		parentSessionId,
-		runId = randomUUID(),
-		signal,
-		onUpdate,
-		modelOverride,
-	} = input;
-
-	const agent = agents.find((entry) => entry.name === agentName);
-	if (!agent) {
-		const available = agents.map((entry) => `"${entry.name}"`).join(", ") || "none";
-		return {
-			agent: agentName,
-			agentSource: "unknown",
-			task,
-			exitCode: 1,
-			messages: [],
-			stderr: `Unknown agent: "${agentName}". Available agents: ${available}.`,
-			usage: emptyUsage(),
-			step,
-		};
-	}
-
-	const args: string[] = ["--mode", "json", "-p", "--no-session"];
-	const modelArg = applyThinkingSuffix(
-		modelOverride ?? agent.model,
-		agent.thinking,
-	);
-	if (modelArg) args.push("--model", modelArg);
-	if (agent.tools?.length) args.push("--tools", agent.tools.join(","));
-
-	let tmpPromptDir: string | null = null;
-	let tmpPromptPath: string | null = null;
-
-	const currentResult: SingleResult = {
-		agent: agentName,
-		agentSource: agent.source,
-		task,
-		exitCode: 0,
-		messages: [],
-		stderr: "",
-		usage: emptyUsage(),
-		model: agent.model,
-		step,
-	};
-
-	const startedAt = Date.now();
-	let pendingTool: { name: string; args: Record<string, unknown>; startedAt: number } | undefined;
-	let processClosed = false;
-
-	const refreshProgress = (isRunning: boolean) => {
-		const progress = deriveProgress(currentResult.messages, currentResult.usage, {
-			isRunning,
-			startedAt,
-			failed: !isRunning && isFailedResult({ ...currentResult, exitCode: currentResult.exitCode || 1 }),
-			pendingTool,
-		});
-		if (isRunning) {
-			currentResult.progress = progress;
-			delete currentResult.progressSummary;
-		} else {
-			currentResult.progressSummary = toProgressSummary(progress);
-			delete currentResult.progress;
-		}
-	};
-
-	const emitUpdate = () => {
-		refreshProgress(!processClosed);
-		onUpdate?.({
-			content: [
-				{
-					type: "text",
-					text: getFinalOutput(currentResult.messages) || "(running...)",
-				},
-			],
-			result: currentResult,
-		});
-	};
-
-	try {
-		if (agent.systemPrompt.trim()) {
-			const tmp = await writePromptToTempFile(agent.name, agent.systemPrompt);
-			tmpPromptDir = tmp.dir;
-			tmpPromptPath = tmp.filePath;
-			args.push(
-				agent.systemPromptMode === "append"
-					? "--append-system-prompt"
-					: "--system-prompt",
-				tmpPromptPath,
-			);
-		}
-
-		args.push(`Task: ${task}`);
-
-		const spawnEnv: Record<string, string | undefined> = {
-			...process.env,
-			[SUBAGENT_CHILD_ENV]: "1",
-			[SUBAGENT_RUN_ID_ENV]: runId,
-			[SUBAGENT_CHILD_AGENT_ENV]: agentName,
-		};
-		if (parentSessionId) {
-			spawnEnv[SUBAGENT_PARENT_SESSION_ENV] = parentSessionId;
-		}
-
-		const exitCode = await new Promise<number>((resolve) => {
-			const invocation = getPiSpawnCommand(args);
-			const proc = spawn(invocation.command, invocation.args, {
-				cwd: cwd ?? defaultCwd,
-				shell: false,
-				stdio: ["ignore", "pipe", "pipe"],
-				env: spawnEnv,
-				detached: false,
-			});
-
-			let buffer = "";
-			let wasAborted = false;
-
-			const processLine = (line: string) => {
-				if (!line.trim()) return;
-				let event: {
-					type?: string;
-					message?: Message;
-					toolName?: string;
-					args?: Record<string, unknown>;
-				};
-				try {
-					event = JSON.parse(line) as {
-						type?: string;
-						message?: Message;
-						toolName?: string;
-						args?: Record<string, unknown>;
-					};
-				} catch {
-					return;
-				}
-
-				if (event.type === "tool_execution_start" && event.toolName) {
-					pendingTool = {
-						name: event.toolName,
-						args: event.args ?? {},
-						startedAt: Date.now(),
-					};
-					emitUpdate();
-				}
-
-				if (event.type === "message_end" && event.message) {
-					const msg = event.message;
-					currentResult.messages.push(msg);
-					if (msg.role === "assistant") {
-						currentResult.usage.turns++;
-						const usage = msg.usage;
-						if (usage) {
-							currentResult.usage.input += usage.input || 0;
-							currentResult.usage.output += usage.output || 0;
-							currentResult.usage.cacheRead += usage.cacheRead || 0;
-							currentResult.usage.cacheWrite += usage.cacheWrite || 0;
-							currentResult.usage.cost += usage.cost?.total || 0;
-							currentResult.usage.contextTokens = usage.totalTokens || 0;
-						}
-						if (!currentResult.model && msg.model) currentResult.model = msg.model;
-						if (msg.stopReason) currentResult.stopReason = msg.stopReason;
-						if (msg.errorMessage) currentResult.errorMessage = msg.errorMessage;
-					}
-					emitUpdate();
-				}
-
-				if (event.type === "tool_result_end" && event.message) {
-					currentResult.messages.push(event.message);
-					if (
-						pendingTool &&
-						event.message.role === "toolResult" &&
-						event.message.toolName === pendingTool.name
-					) {
-						pendingTool = undefined;
-					}
-					emitUpdate();
-				}
-			};
-
-			proc.stdout.on("data", (data: Buffer) => {
-				buffer += data.toString();
-				const lines = buffer.split("\n");
-				buffer = lines.pop() || "";
-				for (const line of lines) processLine(line);
-			});
-
-			proc.stderr.on("data", (data: Buffer) => {
-				currentResult.stderr += data.toString();
-			});
-
-			proc.on("close", (code) => {
-				if (buffer.trim()) processLine(buffer);
-				processClosed = true;
-				pendingTool = undefined;
-				resolve(wasAborted ? 1 : (code ?? 0));
-			});
-
-			proc.on("error", () => resolve(1));
-
-			if (signal) {
-				const killProc = () => {
-					wasAborted = true;
-					proc.kill("SIGTERM");
-					setTimeout(() => {
-						if (!proc.killed) proc.kill("SIGKILL");
-					}, 5000);
-				};
-				if (signal.aborted) killProc();
-				else signal.addEventListener("abort", killProc, { once: true });
-			}
-		});
-
-		currentResult.exitCode = exitCode;
-		refreshProgress(false);
-		return currentResult;
-	} finally {
-		if (tmpPromptPath) {
-			try {
-				fs.unlinkSync(tmpPromptPath);
-			} catch {
-				// ignore
-			}
-		}
-		if (tmpPromptDir) {
-			try {
-				fs.rmdirSync(tmpPromptDir);
-			} catch {
-				// ignore
-			}
-		}
-	}
-}
-
-function getFinalOutput(messages: Message[]): string {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i];
-		if (msg.role === "assistant") {
-			for (const part of msg.content) {
-				if (part.type === "text") return part.text;
-			}
-		}
-	}
-	return "";
-}

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

@@ -1,102 +0,0 @@
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { createAsyncJobTracker } from "./async/job-tracker.ts";
-import type { SubagentEventBus } from "./async/job-tracker.ts";
-import { restoreAsyncJobs, spawnAsyncRun } from "./async/spawn-async.ts";
-import { executeSubagent } from "./execute-subagent.ts";
-import type {
-	ExecuteSubagentInput,
-	SubagentDetails,
-	WaitInput,
-	WaitResult,
-} from "./types.ts";
-import { waitForSubagents } from "./wait.ts";
-
-export interface SubagentRuntimeDeps {
-	getContext: () => ExtensionContext | null;
-	events?: SubagentEventBus;
-}
-
-export interface SubagentRuntime {
-	execute(
-		input: ExecuteSubagentInput,
-		options?: {
-			signal?: AbortSignal;
-			onUpdate?: (partial: AgentToolResult<SubagentDetails>) => void;
-		},
-	): Promise<AgentToolResult<SubagentDetails>>;
-	wait(input?: WaitInput, options?: { signal?: AbortSignal }): Promise<WaitResult>;
-	listAsync(): ReturnType<ReturnType<typeof createAsyncJobTracker>["list"]>;
-}
-
-export function createSubagentRuntime(deps: SubagentRuntimeDeps): SubagentRuntime {
-	const tracker = createAsyncJobTracker();
-
-	return {
-		async execute(input, options = {}) {
-			const ctx = deps.getContext();
-			if (!ctx) {
-				return {
-					content: [
-						{
-							type: "text",
-							text: "Subagent runtime is not bound to an active session.",
-						},
-					],
-					details: {
-						mode: "single",
-						agentScope: "both",
-						projectAgentsDir: null,
-						results: [],
-					},
-				};
-			}
-
-			const parentSessionId = ctx.sessionManager.getSessionId?.() ?? null;
-			const sessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
-
-			if (input.async) {
-				const { result } = spawnAsyncRun({
-					params: input,
-					cwd: ctx.cwd,
-					parentSessionId,
-					sessionFile,
-					tracker,
-					events: deps.events,
-					signal: options.signal,
-				});
-				return result;
-			}
-
-			return executeSubagent(input, {
-				cwd: ctx.cwd,
-				parentSessionId,
-				signal: options.signal,
-				onUpdate: options.onUpdate
-					? (details, text) =>
-							options.onUpdate?.({
-								content: [{ type: "text", text }],
-								details,
-							})
-					: undefined,
-			});
-		},
-
-		async wait(input = {}, _options = {}) {
-			const ctx = deps.getContext();
-			return waitForSubagents(input, {
-				tracker,
-				sessionFile: ctx?.sessionManager.getSessionFile?.() ?? null,
-				events: deps.events,
-			});
-		},
-
-		listAsync() {
-			return tracker.list();
-		},
-
-		_restore(sessionFile: string | null) {
-			restoreAsyncJobs(sessionFile, tracker);
-		},
-	} as SubagentRuntime & { _restore(sessionFile: string | null): void };
-}

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

@@ -1,62 +0,0 @@
-import { StringEnum } from "@earendil-works/pi-ai";
-import { Type, type TSchema } from "typebox";
-
-const TaskItem = Type.Object({
-	agent: Type.String({ description: "Name of the agent to invoke" }),
-	task: Type.String({ description: "Task to delegate to the agent" }),
-	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process" })),
-});
-
-const ChainItem = Type.Object({
-	agent: Type.String({ description: "Name of the agent to invoke" }),
-	task: Type.String({
-		description:
-			"Task with optional {previous} placeholder for prior step output",
-	}),
-	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process" })),
-});
-
-const AgentScopeSchema = StringEnum(["user", "project", "both"] as const, {
-	description: 'Which agent directories to use. Default: "both".',
-	default: "both",
-});
-
-export const SubagentParams: TSchema = Type.Object({
-	agent: Type.Optional(Type.String({ description: "Agent name (single mode)" })),
-	task: Type.Optional(Type.String({ description: "Task to delegate (single mode)" })),
-	tasks: Type.Optional(
-		Type.Array(TaskItem, { description: "Parallel tasks array" }),
-	),
-	chain: Type.Optional(
-		Type.Array(ChainItem, { description: "Sequential chain steps" }),
-	),
-	agentScope: Type.Optional(AgentScopeSchema),
-	concurrency: Type.Optional(
-		Type.Integer({
-			minimum: 1,
-			description: "Parallel mode max concurrency (default 4)",
-		}),
-	),
-	cwd: Type.Optional(Type.String({ description: "Working directory (single mode)" })),
-	async: Type.Optional(
-		Type.Boolean({ description: "Run in background; returns run id immediately" }),
-	),
-});
-
-export const WaitParams: TSchema = Type.Object({
-	id: Type.Optional(
-		Type.String({ description: "Run id or prefix to wait for one specific run" }),
-	),
-	all: Type.Optional(
-		Type.Boolean({
-			description:
-				"Wait for all active runs. Default false: return when the first run completes.",
-		}),
-	),
-	timeoutMs: Type.Optional(
-		Type.Integer({
-			minimum: 1,
-			description: "Timeout in milliseconds (default 30 minutes)",
-		}),
-	),
-});

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

@@ -1,104 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface PiSpawnDeps {
-	platform?: NodeJS.Platform;
-	execPath?: string;
-	argv1?: string;
-	existsSync?: (filePath: string) => boolean;
-	readFileSync?: (filePath: string, encoding: "utf-8") => string;
-	env?: NodeJS.ProcessEnv;
-}
-
-export interface PiSpawnCommand {
-	command: string;
-	args: string[];
-}
-
-const PI_CODING_AGENT_PACKAGE = "@earendil-works/pi-coding-agent";
-
-function isRunnableNodeScript(
-	filePath: string,
-	existsSync: (filePath: string) => boolean,
-): boolean {
-	if (!existsSync(filePath)) return false;
-	return /\.(?:mjs|cjs|js)$/i.test(filePath);
-}
-
-function findPiPackageRootFromEntry(entryPoint: string): string | undefined {
-	let dir = path.dirname(entryPoint);
-	while (dir !== path.dirname(dir)) {
-		const packageJsonPath = path.join(dir, "package.json");
-		if (fs.existsSync(packageJsonPath)) {
-			const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as {
-				name?: unknown;
-			};
-			if (pkg.name === PI_CODING_AGENT_PACKAGE) return dir;
-		}
-		dir = path.dirname(dir);
-	}
-	return undefined;
-}
-
-function resolvePiPackageRoot(): string | undefined {
-	try {
-		const entry = process.argv[1];
-		return entry
-			? findPiPackageRootFromEntry(fs.realpathSync(entry))
-			: undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-export function resolveWindowsPiCliScript(deps: PiSpawnDeps = {}): string | undefined {
-	const existsSync = deps.existsSync ?? fs.existsSync;
-	const readFileSync =
-		deps.readFileSync ??
-		((filePath, encoding) => fs.readFileSync(filePath, encoding));
-	const argv1 = deps.argv1 ?? process.argv[1];
-
-	if (argv1) {
-		const argvPath = path.isAbsolute(argv1) ? argv1 : path.resolve(argv1);
-		if (isRunnableNodeScript(argvPath, existsSync)) return argvPath;
-	}
-
-	try {
-		const root = resolvePiPackageRoot();
-		if (!root) return undefined;
-		const packageJsonPath = path.join(root, "package.json");
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as {
-			bin?: string | Record<string, string>;
-		};
-		const binField = packageJson.bin;
-		const binPath =
-			typeof binField === "string"
-				? binField
-				: (binField?.pi ?? Object.values(binField ?? {})[0]);
-		if (!binPath) return undefined;
-		const candidate = path.resolve(path.dirname(packageJsonPath), binPath);
-		if (isRunnableNodeScript(candidate, existsSync)) return candidate;
-	} catch {
-		return undefined;
-	}
-
-	return undefined;
-}
-
-export function getPiSpawnCommand(
-	args: string[],
-	deps: PiSpawnDeps = {},
-): PiSpawnCommand {
-	const platform = deps.platform ?? process.platform;
-	if (platform === "win32") {
-		const piCliPath = resolveWindowsPiCliScript(deps);
-		if (piCliPath) {
-			return {
-				command: deps.execPath ?? process.execPath,
-				args: [piCliPath, ...args],
-			};
-		}
-	}
-
-	return { command: "pi", args };
-}

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

@@ -1,92 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai";
-import type { AgentProgress, ProgressSummary } from "./progress.ts";
-
-export type AgentScope = "user" | "project" | "both";
-export type SubagentMode = "single" | "parallel" | "chain";
-
-export interface UsageStats {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-	cost: number;
-	contextTokens: number;
-	turns: number;
-}
-
-export interface SingleResult {
-	agent: string;
-	agentSource: "builtin" | "user" | "project" | "unknown";
-	task: string;
-	exitCode: number;
-	messages: Message[];
-	stderr: string;
-	usage: UsageStats;
-	model?: string;
-	stopReason?: string;
-	errorMessage?: string;
-	step?: number;
-	progress?: AgentProgress;
-	progressSummary?: ProgressSummary;
-}
-
-export interface SubagentDetails {
-	mode: SubagentMode;
-	agentScope: AgentScope;
-	projectAgentsDir: string | null;
-	results: SingleResult[];
-	runId?: string;
-	async?: boolean;
-}
-
-export type AsyncRunState = "queued" | "running" | "complete" | "failed";
-
-export interface AsyncRunStatus {
-	id: string;
-	state: AsyncRunState;
-	mode: SubagentMode;
-	sessionId: string | null;
-	createdAt: number;
-	updatedAt: number;
-	agents: string[];
-	exitCode?: number;
-	error?: string;
-}
-
-export interface AsyncRunResult {
-	status: AsyncRunStatus;
-	details: SubagentDetails;
-	finalOutput: string;
-}
-
-export interface ExecuteSubagentInput {
-	agent?: string;
-	task?: string;
-	tasks?: Array<{ agent: string; task: string; cwd?: string }>;
-	chain?: Array<{ agent: string; task: string; cwd?: string }>;
-	cwd?: string;
-	concurrency?: number;
-	async?: boolean;
-	agentScope?: AgentScope;
-	model?: string;
-}
-
-export interface WaitInput {
-	id?: string;
-	all?: boolean;
-	timeoutMs?: number;
-}
-
-export interface WaitResult {
-	completed: AsyncRunSummary[];
-	timedOut: boolean;
-	activeRemaining: number;
-}
-
-export interface AsyncRunSummary {
-	id: string;
-	state: AsyncRunState;
-	agents: string[];
-	exitCode?: number;
-	finalOutput?: string;
-}