@vitos-pizza/vitos-pizza 0.2.0 → 0.3.0

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

@@ -1,100 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { Message } from "@earendil-works/pi-ai";
-import type { SingleResult, UsageStats } from "./types.ts";
-
-export 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 "";
-}
-
-export function isFailedResult(result: SingleResult): boolean {
-	return (
-		result.exitCode !== 0 ||
-		result.stopReason === "error" ||
-		result.stopReason === "aborted"
-	);
-}
-
-export function getResultOutput(result: SingleResult): string {
-	if (isFailedResult(result)) {
-		return (
-			result.errorMessage ||
-			result.stderr ||
-			getFinalOutput(result.messages) ||
-			"(no output)"
-		);
-	}
-	return getFinalOutput(result.messages) || "(no output)";
-}
-
-export function emptyUsage(): UsageStats {
-	return {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		cost: 0,
-		contextTokens: 0,
-		turns: 0,
-	};
-}
-
-export async function mapWithConcurrencyLimit<TIn, TOut>(
-	items: TIn[],
-	concurrency: number,
-	fn: (item: TIn, index: number) => Promise<TOut>,
-): Promise<TOut[]> {
-	if (items.length === 0) return [];
-	const limit = Math.max(1, Math.min(concurrency, items.length));
-	const results: TOut[] = new Array(items.length);
-	let nextIndex = 0;
-
-	const workers = Array.from({ length: limit }, async () => {
-		while (true) {
-			const current = nextIndex++;
-			if (current >= items.length) return;
-			results[current] = await fn(items[current], current);
-		}
-	});
-
-	await Promise.all(workers);
-	return results;
-}
-
-export function writeJsonAtomic(filePath: string, value: unknown): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	const tempPath = `${filePath}.${process.pid}.tmp`;
-	fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), "utf8");
-	fs.renameSync(tempPath, filePath);
-}
-
-export function readJsonFile<T>(filePath: string): T | null {
-	try {
-		return JSON.parse(fs.readFileSync(filePath, "utf8")) as T;
-	} catch {
-		return null;
-	}
-}
-
-export const MAX_PARALLEL_TASKS = 8;
-export const DEFAULT_CONCURRENCY = 4;
-export const PER_TASK_OUTPUT_CAP = 50 * 1024;
-
-export function truncateParallelOutput(output: string): string {
-	const byteLength = Buffer.byteLength(output, "utf8");
-	if (byteLength <= PER_TASK_OUTPUT_CAP) return output;
-
-	let truncated = output.slice(0, PER_TASK_OUTPUT_CAP);
-	while (Buffer.byteLength(truncated, "utf8") > PER_TASK_OUTPUT_CAP) {
-		truncated = truncated.slice(0, -1);
-	}
-	return `${truncated}\n\n[Output truncated: ${byteLength - Buffer.byteLength(truncated, "utf8")} bytes omitted.]`;
-}

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

@@ -1,159 +0,0 @@
-import * as fs from "node:fs";
-import type { AsyncJobTracker, SubagentEventBus } from "./async/job-tracker.ts";
-import { summarizeAsyncRun } from "./async/spawn-async.ts";
-import {
-	getAsyncRootFromSessionFile,
-	getRunDir,
-	isTerminalState,
-} from "./async/storage.ts";
-import { SUBAGENT_ASYNC_COMPLETE } from "./rpc/channels.ts";
-import type { AsyncRunSummary, WaitInput, WaitResult } from "./types.ts";
-
-const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
-const DEFAULT_POLL_INTERVAL_MS = 500;
-
-export interface WaitDeps {
-	tracker: AsyncJobTracker;
-	sessionFile?: string | null;
-	events?: SubagentEventBus;
-	now?: () => number;
-	sleep?: (ms: number) => Promise<void>;
-}
-
-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 [];
-	}
-}
-
-function listActiveRuns(
-	tracker: AsyncJobTracker,
-	sessionFile: string | null | undefined,
-): AsyncRunSummary[] {
-	const asyncRoot = getAsyncRootFromSessionFile(sessionFile ?? null);
-	const summaries: AsyncRunSummary[] = [];
-	const seen = new Set<string>();
-
-	for (const status of tracker.list()) {
-		if (isTerminalState(status.state)) continue;
-		seen.add(status.id);
-		summaries.push({
-			id: status.id,
-			state: status.state,
-			agents: status.agents,
-			exitCode: status.exitCode,
-		});
-	}
-
-	for (const runDir of listRunDirs(asyncRoot)) {
-		const summary = summarizeAsyncRun(runDir);
-		if (!summary || isTerminalState(summary.state) || seen.has(summary.id)) continue;
-		summaries.push(summary);
-	}
-
-	return summaries;
-}
-
-function collectCompleted(
-	tracker: AsyncJobTracker,
-	sessionFile: string | null | undefined,
-	idPrefix?: string,
-): AsyncRunSummary[] {
-	const asyncRoot = getAsyncRootFromSessionFile(sessionFile ?? null);
-	const completed: AsyncRunSummary[] = [];
-	const seen = new Set<string>();
-
-	for (const status of tracker.list()) {
-		if (!isTerminalState(status.state)) continue;
-		if (idPrefix && !status.id.startsWith(idPrefix)) continue;
-		seen.add(status.id);
-		const runDir = getRunDir(asyncRoot, status.id);
-		const summary = summarizeAsyncRun(runDir);
-		completed.push(
-			summary ?? {
-				id: status.id,
-				state: status.state,
-				agents: status.agents,
-				exitCode: status.exitCode,
-			},
-		);
-	}
-
-	return completed;
-}
-
-export async function waitForSubagents(
-	input: WaitInput,
-	deps: WaitDeps,
-): Promise<WaitResult> {
-	const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const now = deps.now ?? (() => Date.now());
-	const sleep =
-		deps.sleep ?? ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)));
-	const deadline = now() + timeoutMs;
-	const waitAll = input.all === true;
-	const idPrefix = input.id;
-
-	let wake = false;
-	const unsub = deps.events?.on(SUBAGENT_ASYNC_COMPLETE, () => {
-		wake = true;
-	});
-
-	try {
-		while (now() < deadline) {
-			const active = listActiveRuns(deps.tracker, deps.sessionFile).filter((run) =>
-				idPrefix ? run.id.startsWith(idPrefix) : true,
-			);
-
-			if (active.length === 0) {
-				return {
-					completed: collectCompleted(deps.tracker, deps.sessionFile, idPrefix),
-					timedOut: false,
-					activeRemaining: 0,
-				};
-			}
-
-			if (!waitAll) {
-				const completed = collectCompleted(deps.tracker, deps.sessionFile, idPrefix);
-				if (completed.length > 0) {
-					return {
-						completed,
-						timedOut: false,
-						activeRemaining: active.length,
-					};
-				}
-			} else {
-				const stillActive = active.filter((run) => !isTerminalState(run.state));
-				if (stillActive.length === 0) {
-					return {
-						completed: collectCompleted(deps.tracker, deps.sessionFile, idPrefix),
-						timedOut: false,
-						activeRemaining: 0,
-					};
-				}
-			}
-
-			wake = false;
-			await sleep(DEFAULT_POLL_INTERVAL_MS);
-			if (!wake) continue;
-		}
-
-		const activeRemaining = listActiveRuns(deps.tracker, deps.sessionFile).filter((run) =>
-			idPrefix ? run.id.startsWith(idPrefix) : true,
-		).length;
-
-		return {
-			completed: collectCompleted(deps.tracker, deps.sessionFile, idPrefix),
-			timedOut: true,
-			activeRemaining,
-		};
-	} finally {
-		unsub?.();
-	}
-}

package/node_modules/@vitos-pizza/subagents/tests/agents.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { discoverAgents, getBuiltinAgentsDir } from "../src/agents.ts";
-
-describe("discoverAgents", () => {
-	it("loads builtin scout, planner, and worker agents", () => {
-		const { agents, builtinAgentsDir } = discoverAgents(process.cwd(), "both");
-		expect(builtinAgentsDir).toBe(getBuiltinAgentsDir());
-		const names = agents.map((agent) => agent.name).sort();
-		expect(names).toEqual(["planner", "scout", "title", "worker"]);
-	});
-
-	it("prefers builtin agents over duplicates", () => {
-		const scout = discoverAgents(process.cwd(), "both").agents.find(
-			(agent) => agent.name === "scout",
-		);
-		expect(scout?.source).toBe("builtin");
-		expect(scout?.tools).toContain("read");
-	});
-});

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

@@ -1,96 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { buildSubagentDetails, executeSubagent } from "../src/execute-subagent.ts";
-import type { AgentConfig } from "../src/agents.ts";
-
-vi.mock("../src/run-agent.ts", () => ({
-	runSingleAgent: vi.fn(async (input) => ({
-		agent: input.agentName,
-		agentSource: "builtin" as const,
-		task: input.task,
-		exitCode: 0,
-		messages: [
-			{
-				role: "assistant",
-				content: [{ type: "text", text: `output:${input.task}` }],
-				api: "test",
-				provider: "test",
-				model: "test",
-				usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2 },
-				stopReason: "stop",
-				timestamp: Date.now(),
-			},
-		],
-		stderr: "",
-		usage: {
-			input: 1,
-			output: 1,
-			cacheRead: 0,
-			cacheWrite: 0,
-			cost: 0,
-			contextTokens: 2,
-			turns: 1,
-		},
-		step: input.step,
-	})),
-}));
-
-vi.mock("../src/agents.ts", async (importOriginal) => {
-	const actual = await importOriginal<typeof import("../src/agents.ts")>();
-	return {
-		...actual,
-		discoverAgents: () => ({
-			agents: [
-				{
-					name: "scout",
-					description: "scout",
-					systemPrompt: "scout",
-					source: "builtin",
-					filePath: "/scout.md",
-				},
-				{
-					name: "planner",
-					description: "planner",
-					systemPrompt: "planner",
-					source: "builtin",
-					filePath: "/planner.md",
-				},
-			] satisfies AgentConfig[],
-			projectAgentsDir: null,
-			builtinAgentsDir: "/agents",
-		}),
-	};
-});
-
-describe("executeSubagent", () => {
-	it("rejects invalid mode combinations", async () => {
-		const result = await executeSubagent(
-			{ agent: "scout", task: "a", chain: [{ agent: "scout", task: "b" }] },
-			{ cwd: process.cwd() },
-		);
-		expect(result.content[0]).toMatchObject({ type: "text" });
-		expect((result.content[0] as { text: string }).text).toContain("Invalid parameters");
-	});
-
-	it("passes {previous} through chain steps", async () => {
-		const result = await executeSubagent(
-			{
-				chain: [
-					{ agent: "scout", task: "first" },
-					{ agent: "planner", task: "plan from {previous}" },
-				],
-			},
-			{ cwd: process.cwd() },
-		);
-		expect(result.details?.mode).toBe("chain");
-		expect(result.details?.results).toHaveLength(2);
-		expect((result.content[0] as { text: string }).text).toContain("output:plan from output:first");
-	});
-});
-
-describe("buildSubagentDetails", () => {
-	it("builds details with mode and scope", () => {
-		const details = buildSubagentDetails("single", "both", null, []);
-		expect(details.mode).toBe("single");
-		expect(details.agentScope).toBe("both");
-	});
-});

package/node_modules/@vitos-pizza/subagents/tests/extension.test.ts

@@ -1,42 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { describe, expect, it, vi } from "vitest";
-import { registerSubagents } from "../extensions/index.ts";
-import { SUBAGENT_PARENT_SESSION_ENV } from "../src/env.ts";
-import { SUBAGENTS_READY } from "../src/rpc/channels.ts";
-
-describe("registerSubagents", () => {
-	it("sets parent session env on session_start and emits ready", () => {
-		const handlers = new Map<string, (event: unknown, ctx: ExtensionContext) => void>();
-		const emitted: Array<{ channel: string; payload: unknown }> = [];
-		const pi = {
-			on: vi.fn((event: string, handler: (event: unknown, ctx: ExtensionContext) => void) => {
-				handlers.set(event, handler);
-			}),
-			registerTool: vi.fn(),
-			events: {
-				emit: vi.fn((channel: string, payload: unknown) => {
-					emitted.push({ channel, payload });
-				}),
-				on: vi.fn(() => () => {}),
-			},
-		};
-
-		delete process.env[SUBAGENT_PARENT_SESSION_ENV];
-		registerSubagents(pi as never);
-
-		const ctx = {
-			cwd: process.cwd(),
-			sessionManager: {
-				getSessionId: () => "parent-session-123",
-				getSessionFile: () => null,
-			},
-		} as unknown as ExtensionContext;
-
-		handlers.get("session_start")?.({}, ctx);
-		expect(process.env[SUBAGENT_PARENT_SESSION_ENV]).toBe("parent-session-123");
-		expect(emitted.some((entry) => entry.channel === SUBAGENTS_READY)).toBe(true);
-
-		handlers.get("session_shutdown")?.({}, ctx);
-		expect(process.env[SUBAGENT_PARENT_SESSION_ENV]).toBeUndefined();
-	});
-});

package/node_modules/@vitos-pizza/subagents/tests/progress.test.ts

@@ -1,206 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai";
-import { describe, expect, it } from "vitest";
-import { deriveProgress, formatToolArgs } from "../src/progress.ts";
-import { subagentResultIsRunning } from "../src/render.ts";
-import { emptyUsage } from "../src/utils.ts";
-
-function assistantToolCall(
-	name: string,
-	args: Record<string, unknown>,
-	timestamp = 1000,
-): Message {
-	return {
-		role: "assistant",
-		content: [
-			{
-				type: "toolCall",
-				id: "call-1",
-				name,
-				arguments: args,
-			},
-		],
-		api: "openai-responses",
-		provider: "openai",
-		model: "gpt-5",
-		usage: {
-			input: 10,
-			output: 5,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 15,
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-		},
-		stopReason: "toolUse",
-		timestamp,
-	};
-}
-
-function toolResult(
-	toolName: string,
-	text: string,
-	timestamp = 2000,
-): Message {
-	return {
-		role: "toolResult",
-		toolCallId: "call-1",
-		toolName,
-		content: [{ type: "text", text }],
-		isError: false,
-		timestamp,
-	};
-}
-
-function assistantText(text: string, timestamp = 3000): Message {
-	return {
-		role: "assistant",
-		content: [{ type: "text", text }],
-		api: "openai-responses",
-		provider: "openai",
-		model: "gpt-5",
-		usage: {
-			input: 20,
-			output: 40,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 60,
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-		},
-		stopReason: "stop",
-		timestamp,
-	};
-}
-
-describe("deriveProgress", () => {
-	it("tracks current tool, recent tools, and tool results", () => {
-		const messages: Message[] = [
-			assistantToolCall("grep", { pattern: "subagent", path: "packages" }),
-		];
-		const usage = emptyUsage();
-		usage.input = 10;
-		usage.output = 5;
-
-		const running = deriveProgress(messages, usage, {
-			isRunning: true,
-			startedAt: Date.now() - 5000,
-			pendingTool: {
-				name: "grep",
-				args: { pattern: "subagent" },
-				startedAt: Date.now() - 1000,
-			},
-		});
-
-		expect(running.status).toBe("running");
-		expect(running.currentTool).toBe("grep");
-		expect(running.recentTools.length).toBeGreaterThan(0);
-		expect(running.recentTools[running.recentTools.length - 1]?.tool).toBe("grep");
-
-		const withResult = deriveProgress(
-			[...messages, toolResult("grep", "packages/subagents/src/render.ts")],
-			usage,
-			{ isRunning: true, startedAt: Date.now() - 5000 },
-		);
-		expect(withResult.toolCount).toBe(1);
-		expect(withResult.recentOutput.some((line) => line.includes("render.ts"))).toBe(
-			true,
-		);
-	});
-
-	it("marks complete when not running", () => {
-		const messages: Message[] = [
-			assistantToolCall("read", { path: "README.md" }),
-			toolResult("read", "# Hello"),
-			assistantText("# Code Context\n\nDone."),
-		];
-		const usage = emptyUsage();
-		usage.input = 30;
-		usage.output = 50;
-
-		const done = deriveProgress(messages, usage, {
-			isRunning: false,
-			startedAt: Date.now() - 10_000,
-		});
-
-		expect(done.status).toBe("complete");
-		expect(done.toolCount).toBe(1);
-		expect(done.recentOutput.some((line) => line.includes("Code Context"))).toBe(true);
-	});
-
-	it("marks failed when requested", () => {
-		const progress = deriveProgress([], emptyUsage(), {
-			isRunning: false,
-			startedAt: Date.now() - 1000,
-			failed: true,
-		});
-		expect(progress.status).toBe("failed");
-	});
-});
-
-describe("formatToolArgs", () => {
-	it("formats key=value pairs", () => {
-		expect(formatToolArgs({ pattern: "scout", path: "packages" })).toContain(
-			"pattern=scout",
-		);
-	});
-});
-
-describe("subagentResultIsRunning", () => {
-	it("detects partial streaming results", () => {
-		expect(
-			subagentResultIsRunning(
-				{
-					content: [{ type: "text", text: "(running...)" }],
-					details: {
-						mode: "single",
-						agentScope: "both",
-						projectAgentsDir: null,
-						results: [
-							{
-								agent: "scout",
-								agentSource: "builtin",
-								task: "scan",
-								exitCode: 0,
-								messages: [],
-								stderr: "",
-								usage: emptyUsage(),
-								progress: {
-									status: "running",
-									recentTools: [],
-									recentOutput: [],
-									toolCount: 0,
-									tokens: 0,
-									durationMs: 100,
-									startedAt: Date.now(),
-								},
-							},
-						],
-					},
-				},
-				{ expanded: false, isPartial: true },
-			),
-		).toBe(true);
-	});
-
-	it("detects parallel placeholders", () => {
-		expect(
-			subagentResultIsRunning({
-				content: [{ type: "text", text: "Parallel: 0/2 done" }],
-				details: {
-					mode: "parallel",
-					agentScope: "both",
-					projectAgentsDir: null,
-					results: [
-						{
-							agent: "scout",
-							agentSource: "builtin",
-							task: "a",
-							exitCode: -1,
-							messages: [],
-							stderr: "",
-							usage: emptyUsage(),
-						},
-					],
-				},
-			}),
-		).toBe(true);
-	});
-});

package/node_modules/@vitos-pizza/subagents/tests/rpc.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	requestSubagentRun,
-	startSubagentRpcServer,
-} from "../src/rpc/client.ts";
-import { SUBAGENTS_RPC_RUN } from "../src/rpc/channels.ts";
-import { createSubagentRuntime } from "../src/runtime.ts";
-import type { SubagentRuntime } from "../src/runtime.ts";
-
-describe("subagent rpc", () => {
-	it("returns a run reply over pi.events", async () => {
-		const handlers = new Map<string, Array<(payload: unknown) => void>>();
-		const events = {
-			emit(channel: string, payload: unknown) {
-				for (const handler of handlers.get(channel) ?? []) handler(payload);
-			},
-			on(channel: string, handler: (payload: unknown) => void) {
-				const list = handlers.get(channel) ?? [];
-				list.push(handler);
-				handlers.set(channel, list);
-				return () => {
-					handlers.set(
-						channel,
-						(handlers.get(channel) ?? []).filter((entry) => entry !== handler),
-					);
-				};
-			},
-		};
-
-		const runtime: SubagentRuntime = {
-			async execute() {
-				return {
-					content: [{ type: "text" as const, text: "ok" }],
-					details: {
-						mode: "single" as const,
-						agentScope: "both" as const,
-						projectAgentsDir: null,
-						results: [],
-					},
-				};
-			},
-			async wait() {
-				return { completed: [], timedOut: false, activeRemaining: 0 };
-			},
-			listAsync() {
-				return [];
-			},
-		};
-
-		startSubagentRpcServer(events, runtime);
-
-		const result = await requestSubagentRun(
-			events,
-			{ agent: "scout", task: "hello" },
-			{ timeoutMs: 1000 },
-		);
-
-		expect(result?.content[0]).toMatchObject({ type: "text", text: "ok" });
-		expect(handlers.has(SUBAGENTS_RPC_RUN)).toBe(true);
-	});
-});
-
-describe("createSubagentRuntime", () => {
-	it("reports missing session context", async () => {
-		const runtime = createSubagentRuntime({
-			getContext: () => null,
-		});
-		const result = await runtime.execute({ agent: "scout", task: "x" });
-		expect(result.content[0]).toMatchObject({
-			type: "text",
-			text: "Subagent runtime is not bound to an active session.",
-		});
-	});
-});