@vitos-pizza/vitos-pizza 0.1.0 → 0.3.0

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

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

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

@@ -1,285 +0,0 @@
-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();
-}

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

@@ -1,187 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai";
-import type { UsageStats } from "./types.ts";
-
-export interface AgentProgress {
-	status: "running" | "complete" | "failed";
-	currentTool?: string;
-	currentToolArgs?: string;
-	currentToolStartedAt?: number;
-	recentTools: Array<{ tool: string; args: string }>;
-	recentOutput: string[];
-	toolCount: number;
-	tokens: number;
-	durationMs: number;
-	startedAt: number;
-}
-
-export type ProgressSummary = Pick<
-	AgentProgress,
-	"toolCount" | "tokens" | "durationMs"
->;
-
-const MAX_RECENT_TOOLS = 5;
-const MAX_RECENT_OUTPUT = 8;
-const OUTPUT_PREVIEW_LEN = 120;
-
-export function formatToolArgs(args: Record<string, unknown>): string {
-	const parts: string[] = [];
-	for (const [key, value] of Object.entries(args)) {
-		if (value === undefined || value === null) continue;
-		const text =
-			typeof value === "string"
-				? value.length > 40
-					? `${value.slice(0, 40)}...`
-					: value
-				: JSON.stringify(value);
-		parts.push(`${key}=${text}`);
-		if (parts.join(" ").length > 80) break;
-	}
-	return parts.join(" ");
-}
-
-function truncatePreview(text: string, maxLen = OUTPUT_PREVIEW_LEN): string {
-	const oneLine = text.replace(/\s+/g, " ").trim();
-	if (oneLine.length <= maxLen) return oneLine;
-	return `${oneLine.slice(0, maxLen)}...`;
-}
-
-function extractTextFromMessage(msg: Message): string | null {
-	if (msg.role === "toolResult") {
-		const parts: string[] = [];
-		for (const part of msg.content) {
-			if (part.type === "text" && part.text.trim()) parts.push(part.text);
-		}
-		return parts.length > 0 ? parts.join("\n") : null;
-	}
-	if (msg.role === "assistant") {
-		for (const part of msg.content) {
-			if (part.type === "text" && part.text.trim()) return part.text;
-		}
-	}
-	return null;
-}
-
-function countCompletedTools(messages: Message[]): number {
-	return messages.filter((msg) => msg.role === "toolResult").length;
-}
-
-export interface DeriveProgressOptions {
-	isRunning: boolean;
-	startedAt: number;
-	failed?: boolean;
-	pendingTool?: { name: string; args: Record<string, unknown>; startedAt: number };
-}
-
-export function deriveProgress(
-	messages: Message[],
-	usage: UsageStats,
-	options: DeriveProgressOptions,
-): AgentProgress {
-	const recentTools: Array<{ tool: string; args: string }> = [];
-	const recentOutput: string[] = [];
-	let currentTool: string | undefined;
-	let currentToolArgs: string | undefined;
-	let currentToolStartedAt: number | undefined;
-
-	for (const msg of messages) {
-		if (msg.role === "assistant") {
-			for (const part of msg.content) {
-				if (part.type === "toolCall") {
-					const entry = {
-						tool: part.name,
-						args: formatToolArgs(part.arguments),
-					};
-					recentTools.push(entry);
-					if (recentTools.length > MAX_RECENT_TOOLS) recentTools.shift();
-					currentTool = part.name;
-					currentToolArgs = entry.args || undefined;
-					currentToolStartedAt = msg.timestamp;
-				}
-			}
-			const text = extractTextFromMessage(msg);
-			if (text) {
-				recentOutput.push(truncatePreview(text));
-				if (recentOutput.length > MAX_RECENT_OUTPUT) recentOutput.shift();
-			}
-		}
-
-		if (msg.role === "toolResult") {
-			const text = extractTextFromMessage(msg);
-			if (text) {
-				recentOutput.push(truncatePreview(text));
-				if (recentOutput.length > MAX_RECENT_OUTPUT) recentOutput.shift();
-			}
-			if (currentTool === msg.toolName) {
-				currentTool = undefined;
-				currentToolArgs = undefined;
-				currentToolStartedAt = undefined;
-			}
-		}
-	}
-
-	if (options.pendingTool) {
-		currentTool = options.pendingTool.name;
-		currentToolArgs = formatToolArgs(options.pendingTool.args) || undefined;
-		currentToolStartedAt = options.pendingTool.startedAt;
-		const entry = { tool: currentTool, args: currentToolArgs ?? "" };
-		if (
-			recentTools.length === 0 ||
-			recentTools[recentTools.length - 1]?.tool !== entry.tool
-		) {
-			recentTools.push(entry);
-			if (recentTools.length > MAX_RECENT_TOOLS) recentTools.shift();
-		}
-	}
-
-	const tokens =
-		usage.input + usage.output + usage.cacheRead + usage.cacheWrite ||
-		usage.contextTokens;
-	const now = Date.now();
-
-	let status: AgentProgress["status"];
-	if (options.isRunning) {
-		status = "running";
-	} else if (options.failed) {
-		status = "failed";
-	} else {
-		status = "complete";
-	}
-
-	return {
-		status,
-		currentTool,
-		currentToolArgs,
-		currentToolStartedAt,
-		recentTools,
-		recentOutput,
-		toolCount: countCompletedTools(messages),
-		tokens,
-		durationMs: Math.max(0, now - options.startedAt),
-		startedAt: options.startedAt,
-	};
-}
-
-export function toProgressSummary(
-	progress: AgentProgress,
-): ProgressSummary {
-	return {
-		toolCount: progress.toolCount,
-		tokens: progress.tokens,
-		durationMs: progress.durationMs,
-	};
-}
-
-export function formatDuration(ms: number): string {
-	if (ms < 1000) return `${ms}ms`;
-	const seconds = Math.floor(ms / 1000);
-	if (seconds < 60) return `${seconds}s`;
-	const minutes = Math.floor(seconds / 60);
-	const rem = seconds % 60;
-	return rem > 0 ? `${minutes}m${rem}s` : `${minutes}m`;
-}
-
-export function formatTokenCount(tokens: number): string {
-	if (tokens < 1000) return `${tokens}`;
-	if (tokens < 1_000_000) return `${(tokens / 1000).toFixed(1)}k`;
-	return `${(tokens / 1_000_000).toFixed(1)}M`;
-}

package/node_modules/@vitos-pizza/subagents/src/render-animation.ts

@@ -1,40 +0,0 @@
-const ANIMATION_INTERVAL_MS = 80;
-const ANIMATION_STATE_KEY = "subagentResultAnimationTimer";
-const FRAME_STATE_KEY = "subagentResultAnimationFrame";
-
-export interface RenderAnimationContext {
-	state: Record<string, unknown>;
-	invalidate?: () => void;
-}
-
-export function ensureSubagentResultAnimation(
-	context: RenderAnimationContext | undefined,
-): void {
-	if (!context || typeof context.invalidate !== "function") return;
-	if (context.state[ANIMATION_STATE_KEY] !== undefined) return;
-
-	context.state[FRAME_STATE_KEY] = 0;
-	context.state[ANIMATION_STATE_KEY] = setInterval(() => {
-		const frame = (context.state[FRAME_STATE_KEY] as number | undefined) ?? 0;
-		context.state[FRAME_STATE_KEY] = frame + 1;
-		context.invalidate?.();
-	}, ANIMATION_INTERVAL_MS);
-}
-
-export function clearSubagentResultAnimation(
-	context: RenderAnimationContext | undefined,
-): void {
-	if (!context) return;
-	const timer = context.state[ANIMATION_STATE_KEY];
-	if (timer !== undefined) {
-		clearInterval(timer as ReturnType<typeof setInterval>);
-		delete context.state[ANIMATION_STATE_KEY];
-	}
-	delete context.state[FRAME_STATE_KEY];
-}
-
-export function getAnimationFrame(
-	context: RenderAnimationContext | undefined,
-): number {
-	return (context?.state[FRAME_STATE_KEY] as number | undefined) ?? 0;
-}