@vitos-pizza/vitos-pizza 0.1.0 → 0.3.0

package/node_modules/@vitos-pizza/subagents/extensions/index.ts

@@ -1,164 +0,0 @@
-/**
- * @vitos-pizza/subagents — subprocess subagent delegation for Vito's Pizzeria.
- */
-
-import type {
-	ExtensionAPI,
-	ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "../src/env.ts";
-import { createSubagentRuntime } from "../src/runtime.ts";
-import type { SubagentRuntime } from "../src/runtime.ts";
-import { SUBAGENTS_READY } from "../src/rpc/channels.ts";
-import { startSubagentRpcServer } from "../src/rpc/client.ts";
-import {
-	clearSubagentResultAnimation,
-	ensureSubagentResultAnimation,
-} from "../src/render-animation.ts";
-import {
-	renderSubagentCall,
-	renderSubagentResult,
-	subagentResultIsRunning,
-	renderWaitCall,
-	renderWaitResult,
-} from "../src/render.ts";
-import { SubagentParams, WaitParams } from "../src/schema.ts";
-import type { ExecuteSubagentInput, WaitInput } from "../src/types.ts";
-
-export interface SubagentsTestHarness {
-	handlers: {
-		session_start?: (event: unknown, ctx: ExtensionContext) => void;
-		session_shutdown?: (event: unknown, ctx: ExtensionContext) => void;
-	};
-	runtime?: SubagentRuntime;
-}
-
-export function registerSubagents(
-	pi: ExtensionAPI,
-): SubagentsTestHarness {
-	const handlers: SubagentsTestHarness["handlers"] = {};
-	let currentCtx: ExtensionContext | null = null;
-	let rpcDispose: (() => void) | null = null;
-
-	const runtime = createSubagentRuntime({
-		getContext: () => currentCtx,
-		events: pi.events,
-	}) as SubagentRuntime & { _restore(sessionFile: string | null): void };
-
-	pi.registerTool({
-		name: "subagent",
-		label: "Subagent",
-		description:
-			"Delegate tasks to specialized subagents. Modes: single (agent+task), parallel (tasks[]), chain (chain[] with {previous}). Use async:true for background runs.",
-		parameters: SubagentParams,
-		async execute(_toolCallId, params, signal, onUpdate, ctx) {
-			currentCtx = ctx;
-			return runtime.execute(params as ExecuteSubagentInput, {
-				signal,
-				onUpdate: onUpdate
-					? (partial) => onUpdate(partial)
-					: undefined,
-			});
-		},
-		renderCall(args, theme) {
-			return renderSubagentCall(args as Record<string, unknown>, theme);
-		},
-		renderResult(result, options, theme, context) {
-			if (subagentResultIsRunning(
-				result as {
-					content: Array<{ type: string; text?: string }>;
-					details?: import("../src/types.ts").SubagentDetails;
-				},
-				options,
-			)) {
-				ensureSubagentResultAnimation(context);
-			} else {
-				clearSubagentResultAnimation(context);
-			}
-			return renderSubagentResult(
-				result as {
-					content: Array<{ type: string; text?: string }>;
-					details?: import("../src/types.ts").SubagentDetails;
-				},
-				options,
-				theme,
-				context,
-			);
-		},
-	});
-
-	pi.registerTool({
-		name: "wait",
-		label: "Wait",
-		description:
-			"Block until background subagent runs finish. Default returns when the first run completes; use all:true to wait for every active run.",
-		parameters: WaitParams,
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			currentCtx = ctx;
-			const outcome = await runtime.wait(params as WaitInput);
-			const summaries = outcome.completed.map((run) => {
-				const status = run.state;
-				const output = run.finalOutput ?? "(no output)";
-				return `- ${run.id} [${run.agents.join(", ")}] ${status}: ${output}`;
-			});
-			const header = outcome.timedOut
-				? `Wait timed out (${outcome.activeRemaining} still active).`
-				: `Wait complete (${outcome.completed.length} run(s)).`;
-			return {
-				content: [
-					{
-						type: "text",
-						text: `${header}\n${summaries.join("\n") || "(none)"}`,
-					},
-				],
-				details: outcome,
-			};
-		},
-		renderCall(args, theme) {
-			return renderWaitCall(args as Record<string, unknown>, theme);
-		},
-		renderResult(result, _options, theme) {
-			return renderWaitResult(
-				result as { content: Array<{ type: string; text?: string }> },
-				theme,
-			);
-		},
-	});
-
-	handlers.session_start = (_event, ctx) => {
-		currentCtx = ctx;
-		if (!process.env[SUBAGENT_CHILD_ENV]) {
-			const sessionId = ctx.sessionManager.getSessionId?.();
-			if (sessionId) {
-				process.env[SUBAGENT_PARENT_SESSION_ENV] = sessionId;
-			}
-		}
-		const sessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
-		(runtime as SubagentRuntime & { _restore(sessionFile: string | null): void })._restore(
-			sessionFile,
-		);
-		rpcDispose?.();
-		rpcDispose = startSubagentRpcServer(pi.events, runtime);
-		pi.events.emit(SUBAGENTS_READY, { version: 1 });
-	};
-
-	pi.on("session_start", handlers.session_start);
-
-	handlers.session_shutdown = () => {
-		delete process.env[SUBAGENT_PARENT_SESSION_ENV];
-		rpcDispose?.();
-		rpcDispose = null;
-		currentCtx = null;
-	};
-
-	pi.on("session_shutdown", handlers.session_shutdown);
-
-	return { handlers, runtime };
-}
-
-export default function subagentsExtension(pi: ExtensionAPI) {
-	if (process.env[SUBAGENT_CHILD_ENV] === "1") {
-		return;
-	}
-	registerSubagents(pi);
-}

package/node_modules/@vitos-pizza/subagents/skills/subagents/SKILL.md

@@ -1,80 +0,0 @@
----
-name: subagents
-description: Delegate exploration, planning, and implementation to Vito's Pizzeria subagents (scout, planner, worker).
----
-
-# Subagents (Vito's Pizzeria)
-
-Use the `subagent` tool to delegate work to focused child agents with isolated context.
-
-## Agent modes
-
-Vito's Pizzeria uses three modes via `/mode` or `F6`:
-
-| Mode | When to use |
-|------|-------------|
-| **agent** | Default balanced work |
-| **plan** | Read-only exploration — scout → planner, `question` for clarification |
-| **execute** | Full implementation after plan is approved |
-
-In **plan** mode the main agent cannot write/edit/bash. Delegate with subagents:
-
-```
-scout → planner → (user confirms) → switch to execute → worker
-```
-
-## Built-in agents
-
-| Agent | Use when |
-|-------|----------|
-| `scout` | Fast codebase recon; returns compressed context |
-| `planner` | Turn context + requirements into an implementation plan |
-| `worker` | Execute an approved plan with narrow, correct edits |
-| `title` | Generate short session titles (used by `@vitos-pizza/session-title`) |
-
-## Typical workflow
-
-```
-scout → planner → worker
-```
-
-### Chain (one tool call)
-
-```json
-{
-  "chain": [
-    { "agent": "scout", "task": "Map the auth module and key entry points" },
-    { "agent": "planner", "task": "Create a plan based on {previous}" },
-    { "agent": "worker", "task": "Implement the plan from {previous}" }
-  ]
-}
-```
-
-### Parallel
-
-```json
-{
-  "tasks": [
-    { "agent": "scout", "task": "Scan packages/subagents" },
-    { "agent": "scout", "task": "Scan packages/permission-system" }
-  ]
-}
-```
-
-### Async + wait
-
-Start work in the background, then block until it finishes:
-
-```json
-{ "agent": "worker", "task": "...", "async": true }
-```
-
-```json
-{ "id": "<runId>" }
-```
-
-via the `wait` tool.
-
-## External modules
-
-Other Vito's Pizzeria extensions can request subagent runs via `pi.events` RPC (`subagents:rpc:run`). Import helpers from `@vitos-pizza/subagents/rpc/client` if needed.

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

@@ -1,166 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-	CONFIG_DIR_NAME,
-	getAgentDir,
-	parseFrontmatter,
-} from "@earendil-works/pi-coding-agent";
-import type { AgentScope } from "./types.ts";
-
-export interface AgentConfig {
-	name: string;
-	description: string;
-	tools?: string[];
-	model?: string;
-	thinking?: string;
-	systemPromptMode?: "append" | "replace";
-	systemPrompt: string;
-	source: "builtin" | "user" | "project";
-	filePath: string;
-}
-
-export interface AgentDiscoveryResult {
-	agents: AgentConfig[];
-	projectAgentsDir: string | null;
-	builtinAgentsDir: string;
-}
-
-const THINKING_LEVELS = new Set([
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max",
-]);
-
-export function getBuiltinAgentsDir(): string {
-	return path.join(
-		path.dirname(fileURLToPath(import.meta.url)),
-		"..",
-		"agents",
-	);
-}
-
-function loadAgentsFromDir(
-	dir: string,
-	source: AgentConfig["source"],
-): AgentConfig[] {
-	if (!fs.existsSync(dir)) return [];
-
-	let entries: fs.Dirent[];
-	try {
-		entries = fs.readdirSync(dir, { withFileTypes: true });
-	} catch {
-		return [];
-	}
-
-	const agents: AgentConfig[] = [];
-	for (const entry of entries) {
-		if (!entry.name.endsWith(".md")) continue;
-		if (!entry.isFile() && !entry.isSymbolicLink()) continue;
-
-		const filePath = path.join(dir, entry.name);
-		let content: string;
-		try {
-			content = fs.readFileSync(filePath, "utf-8");
-		} catch {
-			continue;
-		}
-
-		const { frontmatter, body } = parseFrontmatter<Record<string, string>>(
-			content,
-		);
-		if (!frontmatter.name || !frontmatter.description) continue;
-
-		const tools = frontmatter.tools
-			?.split(",")
-			.map((tool) => tool.trim())
-			.filter(Boolean);
-
-		const systemPromptMode =
-			frontmatter.systemPromptMode === "append" ? "append" : "replace";
-
-		agents.push({
-			name: frontmatter.name,
-			description: frontmatter.description,
-			tools: tools && tools.length > 0 ? tools : undefined,
-			model: frontmatter.model,
-			thinking: frontmatter.thinking,
-			systemPromptMode,
-			systemPrompt: body,
-			source,
-			filePath,
-		});
-	}
-
-	return agents;
-}
-
-function isDirectory(candidate: string): boolean {
-	try {
-		return fs.statSync(candidate).isDirectory();
-	} catch {
-		return false;
-	}
-}
-
-function findNearestProjectAgentsDir(cwd: string): string | null {
-	let currentDir = cwd;
-	while (true) {
-		const candidate = path.join(currentDir, CONFIG_DIR_NAME, "agents");
-		if (isDirectory(candidate)) return candidate;
-
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) return null;
-		currentDir = parentDir;
-	}
-}
-
-export function applyThinkingSuffix(
-	model: string | undefined,
-	thinking: string | undefined,
-): string | undefined {
-	if (!model || !thinking) return model;
-	const colonIdx = model.lastIndexOf(":");
-	if (
-		colonIdx !== -1 &&
-		THINKING_LEVELS.has(model.substring(colonIdx + 1))
-	) {
-		return `${model.slice(0, colonIdx)}:${thinking}`;
-	}
-	return `${model}:${thinking}`;
-}
-
-export function discoverAgents(
-	cwd: string,
-	scope: AgentScope = "both",
-): AgentDiscoveryResult {
-	const builtinAgentsDir = getBuiltinAgentsDir();
-	const userDir = path.join(getAgentDir(), "agents");
-	const projectAgentsDir = findNearestProjectAgentsDir(cwd);
-
-	const builtinAgents = loadAgentsFromDir(builtinAgentsDir, "builtin");
-	const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
-	const projectAgents =
-		scope === "user" || !projectAgentsDir
-			? []
-			: loadAgentsFromDir(projectAgentsDir, "project");
-
-	const agentMap = new Map<string, AgentConfig>();
-	for (const agent of builtinAgents) agentMap.set(agent.name, agent);
-	if (scope === "both" || scope === "user") {
-		for (const agent of userAgents) agentMap.set(agent.name, agent);
-	}
-	if (scope === "both" || scope === "project") {
-		for (const agent of projectAgents) agentMap.set(agent.name, agent);
-	}
-
-	return {
-		agents: Array.from(agentMap.values()),
-		projectAgentsDir,
-		builtinAgentsDir,
-	};
-}

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

@@ -1,71 +0,0 @@
-import {
-	SUBAGENT_ASYNC_COMPLETE,
-	SUBAGENT_ASYNC_STARTED,
-} from "../rpc/channels.ts";
-import type { AsyncRunStatus, ExecuteSubagentInput } from "../types.ts";
-
-export interface AsyncJobTracker {
-	track(runId: string, status: AsyncRunStatus): void;
-	update(runId: string, patch: Partial<AsyncRunStatus>): void;
-	get(runId: string): AsyncRunStatus | undefined;
-	list(): AsyncRunStatus[];
-	remove(runId: string): void;
-	clear(): void;
-}
-
-export function createAsyncJobTracker(): AsyncJobTracker {
-	const jobs = new Map<string, AsyncRunStatus>();
-
-	return {
-		track(runId, status) {
-			jobs.set(runId, status);
-		},
-		update(runId, patch) {
-			const current = jobs.get(runId);
-			if (!current) return;
-			jobs.set(runId, { ...current, ...patch, updatedAt: Date.now() });
-		},
-		get(runId) {
-			return jobs.get(runId);
-		},
-		list() {
-			return Array.from(jobs.values());
-		},
-		remove(runId) {
-			jobs.delete(runId);
-		},
-		clear() {
-			jobs.clear();
-		},
-	};
-}
-
-export interface SubagentEventBus {
-	emit(channel: string, payload: unknown): void;
-	on(channel: string, handler: (payload: unknown) => void): () => void;
-}
-
-export function emitAsyncStarted(
-	events: SubagentEventBus | undefined,
-	payload: {
-		id: string;
-		mode: AsyncRunStatus["mode"];
-		sessionId: string | null;
-		agents: string[];
-	},
-): void {
-	events?.emit(SUBAGENT_ASYNC_STARTED, payload);
-}
-
-export function emitAsyncComplete(
-	events: SubagentEventBus | undefined,
-	payload: {
-		id: string;
-		exitCode: number;
-		finalOutput: string;
-	},
-): void {
-	events?.emit(SUBAGENT_ASYNC_COMPLETE, payload);
-}
-
-export type AsyncExecuteInput = ExecuteSubagentInput;

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

@@ -1,220 +0,0 @@
-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,
-	};
-}