@vitos-pizza/vitos-pizza 0.1.0

package/node_modules/@vitos-pizza/permission-system/tests/policy-loader.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { mergePermissionMaps } from "../src/policy-loader.ts";
+
+describe("policy-loader merge", () => {
+	it("merges nested maps and overrides scalars", () => {
+		const merged = mergePermissionMaps(
+			{
+				"*": "allow",
+				bash: { "*": "ask", "git status": "allow" },
+			},
+			{
+				write: "ask",
+				bash: { "npm install": "deny" },
+			},
+		);
+
+		expect(merged["*"]).toBe("allow");
+		expect(merged.write).toBe("ask");
+		expect(merged.bash).toEqual({
+			"*": "ask",
+			"git status": "allow",
+			"npm install": "deny",
+		});
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/system-prompt-sanitizer.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { sanitizeAvailableToolsSection } from "../src/sanitizers/system-prompt.ts";
+
+describe("system-prompt sanitizer", () => {
+	it("removes denied tools from Available tools section", () => {
+		const prompt = [
+			"Available tools:",
+			"- read: read files",
+			"- bash: run commands",
+			"- write: write files",
+			"",
+			"Guidelines:",
+			"- use bash for file operations like ls, rg, find",
+		].join("\n");
+
+		const result = sanitizeAvailableToolsSection(prompt, ["read"]);
+		expect(result.removed).toBe(true);
+		expect(result.prompt).toContain("- read:");
+		expect(result.prompt).not.toContain("- bash:");
+		expect(result.prompt).not.toContain("use bash for file operations");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/wildcard-matcher.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import {
+	compileWildcardPattern,
+	findCompiledWildcardMatch,
+	wildcardMatch,
+} from "../src/wildcard-matcher.ts";
+
+describe("wildcard-matcher", () => {
+	it("matches exact strings", () => {
+		expect(wildcardMatch("git status", "git status")).toBe(true);
+		expect(wildcardMatch("git status", "git diff")).toBe(false);
+	});
+
+	it("supports trailing optional args", () => {
+		expect(wildcardMatch("git *", "git")).toBe(true);
+		expect(wildcardMatch("git *", "git status")).toBe(true);
+	});
+
+	it("uses last-match-wins ordering", () => {
+		const compiled = [
+			compileWildcardPattern("*", "ask"),
+			compileWildcardPattern("git status", "allow"),
+		];
+		const match = findCompiledWildcardMatch(compiled, "git status");
+		expect(match?.state).toBe("allow");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/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/node_modules/@vitos-pizza/permission-system/vitest.config.ts

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

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

@@ -0,0 +1,79 @@
+/**
+ * @vitos-pizza/question — structured ask-user question tool.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { startQuestionFileWatcher } from "../src/forwarding/file-watcher.ts";
+import { startQuestionRpcServer } from "../src/forwarding/forwarder.ts";
+import {
+	promptQuestionLocally,
+	registerQuestionTool,
+} from "../src/register-tool.ts";
+
+export default function (
+	pi: import("@earendil-works/pi-coding-agent").ExtensionAPI,
+) {
+	let activeCtx: ExtensionContext | null = null;
+	let stopFileWatcher: (() => void) | null = null;
+	const agentDir = getAgentDir();
+
+	const unsubRpc = startQuestionRpcServer(pi.events, async (payload) => {
+		const ctx = activeCtx;
+		if (!ctx?.hasUI) {
+			return {
+				question: payload.question,
+				options: payload.options.map((o) => o.label),
+				answer: null,
+				cancelled: true,
+				responderSessionId: ctx?.sessionManager.getSessionId?.() ?? "unknown",
+				respondedAt: Date.now(),
+			};
+		}
+		return promptQuestionLocally(
+			ctx.ui,
+			{ question: payload.question, options: payload.options },
+			ctx.sessionManager.getSessionId?.() ?? "unknown",
+		);
+	});
+
+	registerQuestionTool(pi, {
+		getAgentDir: () => agentDir,
+		events: pi.events,
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		activeCtx = ctx;
+		stopFileWatcher?.();
+
+		const sessionId = ctx.sessionManager.getSessionId?.();
+		if (sessionId && ctx.hasUI) {
+			stopFileWatcher = startQuestionFileWatcher({
+				agentDir,
+				sessionId,
+				responderSessionId: sessionId,
+				showQuestion: async (params) => {
+					if (!activeCtx?.hasUI) {
+						return {
+							question: params.question,
+							options: params.options.map((o) => o.label),
+							answer: null,
+							cancelled: true,
+							responderSessionId: sessionId,
+							respondedAt: Date.now(),
+						};
+					}
+					return promptQuestionLocally(activeCtx.ui, params, sessionId);
+				},
+			});
+		}
+	});
+
+	pi.on("session_shutdown", (_event, _ctx) => {
+		stopFileWatcher?.();
+		stopFileWatcher = null;
+		activeCtx = null;
+	});
+
+	void unsubRpc;
+}

package/node_modules/@vitos-pizza/question/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@vitos-pizza/question",
+	"version": "0.1.0",
+	"description": "Structured ask-user question tool 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-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*",
+		"vitest": "^3.2.4"
+	}
+}

package/node_modules/@vitos-pizza/question/src/forwarding/channels.ts

@@ -0,0 +1,6 @@
+export const QUESTION_RPC_PROMPT = "question:rpc:prompt";
+export const QUESTION_RPC_PROMPT_REPLY_PREFIX = "question:rpc:prompt:reply:";
+
+export function questionReplyChannel(requestId: string): string {
+	return `${QUESTION_RPC_PROMPT_REPLY_PREFIX}${requestId}`;
+}

package/node_modules/@vitos-pizza/question/src/forwarding/file-watcher.ts

@@ -0,0 +1,106 @@
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	renameSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type {
+	ForwardedQuestionRequest,
+	ForwardedQuestionResponse,
+	QuestionParams,
+} from "../types.ts";
+import { getQuestionForwardingRoot } from "./forwarder.ts";
+
+const PROCESSING_SUFFIX = ".processing";
+
+export function startQuestionFileWatcher(options: {
+	agentDir: string;
+	sessionId: string;
+	responderSessionId: string;
+	showQuestion: (params: QuestionParams) => Promise<ForwardedQuestionResponse>;
+	pollIntervalMs?: number;
+}): () => void {
+	const forwardingRoot = getQuestionForwardingRoot(
+		options.agentDir,
+		options.sessionId,
+	);
+	const requestsDir = join(forwardingRoot, "requests");
+	const responsesDir = join(forwardingRoot, "responses");
+	mkdirSync(requestsDir, { recursive: true });
+	mkdirSync(responsesDir, { recursive: true });
+
+	const inFlight = new Set<string>();
+	const pollIntervalMs = options.pollIntervalMs ?? 250;
+
+	const timer = setInterval(() => {
+		if (!existsSync(requestsDir)) return;
+		for (const file of readdirSync(requestsDir)) {
+			if (!file.endsWith(".json") || file.endsWith(PROCESSING_SUFFIX)) continue;
+			const requestId = file.replace(/\.json$/, "");
+			if (inFlight.has(requestId)) continue;
+
+			const requestPath = join(requestsDir, file);
+			const processingPath = `${requestPath}${PROCESSING_SUFFIX}`;
+			try {
+				renameSync(requestPath, processingPath);
+			} catch {
+				continue;
+			}
+
+			inFlight.add(requestId);
+			void handleRequest(processingPath, requestId);
+		}
+	}, pollIntervalMs);
+
+	async function handleRequest(processingPath: string, requestId: string) {
+		try {
+			const request = JSON.parse(
+				readFileSync(processingPath, "utf8"),
+			) as ForwardedQuestionRequest;
+
+			const response = await options.showQuestion({
+				question: request.question,
+				options: request.options,
+			});
+
+			writeFileSync(
+				join(responsesDir, `${requestId}.json`),
+				JSON.stringify(response),
+				"utf8",
+			);
+		} catch {
+			const failure: ForwardedQuestionResponse = {
+				question: "",
+				options: [],
+				answer: null,
+				cancelled: true,
+				responderSessionId: options.responderSessionId,
+				respondedAt: Date.now(),
+			};
+			try {
+				writeFileSync(
+					join(responsesDir, `${requestId}.json`),
+					JSON.stringify(failure),
+					"utf8",
+				);
+			} catch {
+				// ignore
+			}
+		} finally {
+			inFlight.delete(requestId);
+			try {
+				unlinkSync(processingPath);
+			} catch {
+				// ignore
+			}
+		}
+	}
+
+	return () => {
+		clearInterval(timer);
+	};
+}

package/node_modules/@vitos-pizza/question/src/forwarding/forwarder.ts

@@ -0,0 +1,187 @@
+import { randomUUID } from "node:crypto";
+import {
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type {
+	ForwardedQuestionRequest,
+	ForwardedQuestionResponse,
+	QuestionOption,
+	QuestionParams,
+} from "../types.ts";
+import { QUESTION_RPC_PROMPT, questionReplyChannel } from "./channels.ts";
+
+interface EventBus {
+	emit(channel: string, payload: unknown): void;
+	on(channel: string, handler: (payload: unknown) => void): () => void;
+}
+
+export function getQuestionForwardingRoot(
+	agentDir: string,
+	sessionId: string,
+): string {
+	return join(agentDir, "question-forwarding", sessionId);
+}
+
+function getForwardingDirs(forwardingRoot: string): {
+	requestsDir: string;
+	responsesDir: string;
+} {
+	const requestsDir = join(forwardingRoot, "requests");
+	const responsesDir = join(forwardingRoot, "responses");
+	mkdirSync(requestsDir, { recursive: true });
+	mkdirSync(responsesDir, { recursive: true });
+	return { requestsDir, responsesDir };
+}
+
+export async function forwardQuestionPrompt(options: {
+	events?: EventBus;
+	agentDir?: string;
+	targetSessionId: string;
+	requesterSessionId: string;
+	params: QuestionParams;
+	timeoutMs?: number;
+}): Promise<ForwardedQuestionResponse | null> {
+	const requestId = randomUUID();
+	const payload = {
+		requestId,
+		targetSessionId: options.targetSessionId,
+		requesterSessionId: options.requesterSessionId,
+		question: options.params.question,
+		options: options.params.options,
+	};
+
+	if (options.events) {
+		const rpcReply = await waitForRpcReply(
+			options.events,
+			payload,
+			options.timeoutMs ?? 600_000,
+		);
+		if (rpcReply) return rpcReply;
+	}
+
+	if (options.agentDir) {
+		return waitForFileReply(
+			options.agentDir,
+			options.targetSessionId,
+			{
+				requestId,
+				requesterSessionId: options.requesterSessionId,
+				targetSessionId: options.targetSessionId,
+				params: options.params,
+			},
+			options.timeoutMs ?? 600_000,
+		);
+	}
+
+	return null;
+}
+
+function waitForRpcReply(
+	events: EventBus,
+	payload: {
+		requestId: string;
+		targetSessionId: string;
+		requesterSessionId: string;
+		question: string;
+		options: QuestionOption[];
+	},
+	timeoutMs: number,
+): Promise<ForwardedQuestionResponse | null> {
+	return new Promise((resolve) => {
+		const replyChannel = questionReplyChannel(payload.requestId);
+		let settled = false;
+		const timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			unsub();
+			resolve(null);
+		}, timeoutMs);
+
+		const unsub = events.on(replyChannel, (reply) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			unsub();
+			resolve(reply as ForwardedQuestionResponse);
+		});
+
+		events.emit(QUESTION_RPC_PROMPT, payload);
+	});
+}
+
+function waitForFileReply(
+	agentDir: string,
+	targetSessionId: string,
+	payload: {
+		requestId: string;
+		requesterSessionId: string;
+		targetSessionId: string;
+		params: QuestionParams;
+	},
+	timeoutMs: number,
+): Promise<ForwardedQuestionResponse | null> {
+	const forwardingRoot = getQuestionForwardingRoot(agentDir, targetSessionId);
+	const { requestsDir, responsesDir } = getForwardingDirs(forwardingRoot);
+	const request: ForwardedQuestionRequest = {
+		id: payload.requestId,
+		createdAt: Date.now(),
+		requesterSessionId: payload.requesterSessionId,
+		targetSessionId: payload.targetSessionId,
+		question: payload.params.question,
+		options: payload.params.options,
+	};
+	writeFileSync(
+		join(requestsDir, `${request.id}.json`),
+		JSON.stringify(request),
+		"utf8",
+	);
+
+	const started = Date.now();
+	return new Promise((resolve) => {
+		const timer = setInterval(() => {
+			if (Date.now() - started > timeoutMs) {
+				clearInterval(timer);
+				resolve(null);
+				return;
+			}
+			for (const file of readdirSync(responsesDir)) {
+				if (!file.startsWith(request.id)) continue;
+				try {
+					const response = JSON.parse(
+						readFileSync(join(responsesDir, file), "utf8"),
+					) as ForwardedQuestionResponse;
+					unlinkSync(join(responsesDir, file));
+					clearInterval(timer);
+					resolve(response);
+					return;
+				} catch {
+					// keep polling
+				}
+			}
+		}, 250);
+	});
+}
+
+export function startQuestionRpcServer(
+	events: EventBus,
+	handler: (payload: {
+		requestId: string;
+		question: string;
+		options: QuestionOption[];
+	}) => Promise<ForwardedQuestionResponse>,
+): () => void {
+	return events.on(QUESTION_RPC_PROMPT, async (raw) => {
+		const payload = raw as {
+			requestId: string;
+			question: string;
+			options: QuestionOption[];
+		};
+		const response = await handler(payload);
+		events.emit(questionReplyChannel(payload.requestId), response);
+	});
+}

package/node_modules/@vitos-pizza/question/src/parent-session.ts

@@ -0,0 +1,18 @@
+export const SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD";
+
+export const SUBAGENT_PARENT_SESSION_ENV_CANDIDATES = [
+	"PI_AGENT_ROUTER_PARENT_SESSION_ID",
+	"PI_SUBAGENT_PARENT_SESSION",
+] as const;
+
+export function isSubagentChild(): boolean {
+	return process.env[SUBAGENT_CHILD_ENV] === "1";
+}
+
+export function resolveParentSessionId(): string | null {
+	for (const key of SUBAGENT_PARENT_SESSION_ENV_CANDIDATES) {
+		const value = process.env[key]?.trim();
+		if (value) return value;
+	}
+	return null;
+}