@vitos-pizza/vitos-pizza 0.1.0

package/packages/subagents/src/spawn.ts

@@ -0,0 +1,104 @@
+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/packages/subagents/src/types.ts

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

package/packages/subagents/src/utils.ts

@@ -0,0 +1,100 @@
+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/packages/subagents/src/wait.ts

@@ -0,0 +1,159 @@
+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/packages/subagents/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": true
+	},
+	"include": [
+		"extensions/**/*.ts",
+		"src/**/*.ts",
+		"tests/**/*.ts",
+		"vitest.config.ts"
+	],
+	"exclude": ["node_modules"]
+}

package/packages/subagents/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["tests/**/*.test.ts"],
+	},
+});

package/packages/ui-enhancements/extensions/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @vitos-pizza/ui-enhancements — TUI and UI enhancements for Vito's Pizzeria.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerUiEnhancements } from "../src/register-ui-enhancements.ts";
+
+export default function (pi: ExtensionAPI): void {
+	registerUiEnhancements(pi);
+}

package/packages/ui-enhancements/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "@vitos-pizza/ui-enhancements",
+	"version": "0.1.0",
+	"description": "TUI and UI enhancements for Vito's Pizzeria Pi distribution",
+	"type": "module",
+	"license": "MIT",
+	"private": true,
+	"scripts": {
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write ."
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-agent-core": "*",
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*",
+		"vitest": "^3.2.4"
+	}
+}

package/packages/ui-enhancements/src/bash-readonly.ts

@@ -0,0 +1,82 @@
+/** Read-only bash commands that are safe to collapse by default. */
+const READONLY_BASH_COMMANDS = new Set([
+	"cat",
+	"head",
+	"tail",
+	"wc",
+	"sort",
+	"uniq",
+	"cut",
+	"tr",
+	"jq",
+	"yq",
+	"awk",
+	"sed",
+	"grep",
+	"rg",
+	"fd",
+	"fzf",
+	"diff",
+	"patch",
+	"xz",
+	"zstd",
+	"gzip",
+	"gunzip",
+	"base64",
+	"md5sum",
+	"sha256sum",
+	"sha1sum",
+	"stat",
+	"file",
+	"dirname",
+	"basename",
+	"realpath",
+	"readlink",
+	"hexdump",
+	"od",
+	"strings",
+	"tree",
+	"ls",
+	"find",
+	"echo",
+	"printf",
+	"date",
+	"id",
+	"whoami",
+	"pwd",
+	"env",
+	"export",
+	"unset",
+]);
+
+const DESTRUCTIVE_PATTERN =
+	/(?:\s>>?\s?|\|\s*(?:tee|xargs)|\brm\b|\bmv\b|\bcp\b|\bdd\b|\btruncate\b|\bchmod\b|\bchown\b|\btouch\b|\bmkdir\b|\brmdir\b|\bunlink\b|\bkill\b|\bpkill\b|\bkillall\b|\bwget\b|\bcurl\b|\bnc\b|\bexec\b|\bsource\b)/i;
+
+/**
+ * Detect if a bash command is read-only and safe to collapse.
+ * Every command in the chain must be in READONLY_BASH_COMMANDS.
+ */
+export function isReadonlyBash(command: string): boolean {
+	const trimmed = command.trim();
+	if (!trimmed) return false;
+
+	const chain = trimmed.split(/\s*(?:;|\|\||&&)\s*/);
+
+	for (const segment of chain) {
+		const primary = segment
+			.trim()
+			.split(/\s*\|\s*/)[0]
+			?.trim()
+			.split(/\s+/)[0];
+		if (!primary) continue;
+		if (!READONLY_BASH_COMMANDS.has(primary)) {
+			return false;
+		}
+	}
+
+	if (DESTRUCTIVE_PATTERN.test(trimmed)) {
+		return false;
+	}
+
+	return true;
+}

package/packages/ui-enhancements/src/chrome/agent-mode-badge.ts

@@ -0,0 +1,60 @@
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+
+export const AGENT_MODE_CHANGED = "agent-mode:changed";
+
+export type AgentModeDisplayColor = "dim" | "accent" | "warning";
+
+export interface AgentModeChangedPayload {
+	mode: "agent" | "plan" | "execute";
+	label: string;
+	color: AgentModeDisplayColor;
+}
+
+let currentAgentMode: AgentModeChangedPayload | null = null;
+
+function isPayload(value: unknown): value is AgentModeChangedPayload {
+	if (!value || typeof value !== "object") return false;
+	const payload = value as Partial<AgentModeChangedPayload>;
+	return (
+		(payload.mode === "agent" ||
+			payload.mode === "plan" ||
+			payload.mode === "execute") &&
+		typeof payload.label === "string" &&
+		(payload.color === "dim" ||
+			payload.color === "accent" ||
+			payload.color === "warning")
+	);
+}
+
+export function getAgentModeBadge(): AgentModeChangedPayload | null {
+	return currentAgentMode;
+}
+
+export function formatAgentModeSuffix(
+	payload: AgentModeChangedPayload | null,
+	theme: Theme,
+): string {
+	if (!payload || payload.mode === "agent") return "";
+	return theme.fg(payload.color, ` · ${payload.label}`);
+}
+
+export function registerAgentModeBadge(
+	pi: ExtensionAPI,
+	requestRender: () => void,
+): () => void {
+	const unsubChanged = pi.events.on(AGENT_MODE_CHANGED, (value) => {
+		if (!isPayload(value)) return;
+		currentAgentMode = value;
+		requestRender();
+	});
+
+	pi.on("session_shutdown", () => {
+		currentAgentMode = null;
+	});
+
+	return unsubChanged;
+}
+
+export function resetAgentModeBadgeForTests(): void {
+	currentAgentMode = null;
+}