@vitos-pizza/vitos-pizza 0.1.0

package/node_modules/@vitos-pizza/question/src/question-ui.ts

@@ -0,0 +1,238 @@
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import {
+	CURSOR_MARKER,
+	Input,
+	Key,
+	matchesKey,
+	parseKey,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+import type { QuestionParams, QuestionUiResult } from "./types.ts";
+
+const CUSTOM_INPUT_PLACEHOLDER = "Type your answer";
+
+export async function runQuestionUi(
+	ui: ExtensionUIContext,
+	params: QuestionParams,
+): Promise<QuestionUiResult | null> {
+	if (params.options.length === 0) {
+		return null;
+	}
+
+	const options = params.options;
+	const customInputIndex = options.length;
+
+	return ui.custom<QuestionUiResult | null>((tui, theme, _kb, done) => {
+		let optionIndex = 0;
+		let cachedLines: string[] | undefined;
+		const customInput = new Input();
+
+		customInput.onSubmit = (value) => {
+			const trimmed = value.trim();
+			if (trimmed && optionIndex === customInputIndex) {
+				done({ answer: trimmed, wasCustom: true });
+			}
+		};
+
+		function isOnCustomInput(): boolean {
+			return optionIndex === customInputIndex;
+		}
+
+		function refresh() {
+			cachedLines = undefined;
+			tui.requestRender();
+		}
+
+		function selectPresetOption(index: number) {
+			const selected = options[index];
+			if (!selected) return;
+			done({
+				answer: selected.label,
+				wasCustom: false,
+				index: index + 1,
+			});
+		}
+
+		function handleInput(data: string) {
+			if (matchesKey(data, Key.escape)) {
+				done(null);
+				return;
+			}
+
+			if (isOnCustomInput()) {
+				if (matchesKey(data, Key.up)) {
+					optionIndex = Math.max(0, optionIndex - 1);
+					customInput.focused = false;
+					refresh();
+					return;
+				}
+				if (matchesKey(data, Key.down)) {
+					refresh();
+					return;
+				}
+				if (matchesKey(data, Key.enter)) {
+					const trimmed = customInput.getValue().trim();
+					if (trimmed) {
+						done({ answer: trimmed, wasCustom: true });
+					}
+					return;
+				}
+				customInput.focused = true;
+				customInput.handleInput(data);
+				refresh();
+				return;
+			}
+
+			if (matchesKey(data, Key.up)) {
+				optionIndex = Math.max(0, optionIndex - 1);
+				customInput.focused = false;
+				refresh();
+				return;
+			}
+			if (matchesKey(data, Key.down)) {
+				optionIndex = Math.min(customInputIndex, optionIndex + 1);
+				customInput.focused = optionIndex === customInputIndex;
+				refresh();
+				return;
+			}
+			if (matchesKey(data, Key.enter)) {
+				selectPresetOption(optionIndex);
+				return;
+			}
+
+			const key = parseKey(data);
+			if (key && /^[1-9]$/.test(key)) {
+				const index = Number(key) - 1;
+				if (index <= customInputIndex) {
+					optionIndex = index;
+					customInput.focused = index === customInputIndex;
+					refresh();
+				}
+			}
+		}
+
+		function renderCustomInputRow(
+			prefix: string,
+			numberLabel: string,
+			availableWidth: number,
+			selected: boolean,
+		): string[] {
+			const numberPrefix = `${numberLabel} `;
+			const numberWidth = visibleWidth(prefix + numberPrefix);
+			const inputWidth = Math.max(1, availableWidth - numberWidth);
+			const value = customInput.getValue();
+
+			if (selected && value.length > 0) {
+				customInput.focused = true;
+				const [inputLine = ""] = customInput.render(inputWidth);
+				const stripped = inputLine.startsWith("> ")
+					? inputLine.slice(2)
+					: inputLine;
+				return [`${prefix}${numberPrefix}${stripped}`];
+			}
+
+			if (selected) {
+				customInput.focused = true;
+				const marker = CURSOR_MARKER;
+				const firstChar = CUSTOM_INPUT_PLACEHOLDER[0] ?? " ";
+				const rest = CUSTOM_INPUT_PLACEHOLDER.slice(1);
+				const cursorFirst = `\x1b[7m${firstChar}\x1b[27m`;
+				const restPlaceholder = theme.fg("dim", rest);
+				const field = `${marker}${cursorFirst}${restPlaceholder}`;
+				const padding = " ".repeat(
+					Math.max(0, inputWidth - visibleWidth(CUSTOM_INPUT_PLACEHOLDER)),
+				);
+				return [`${prefix}${numberPrefix}${field}${padding}`];
+			}
+
+			customInput.focused = false;
+			const display =
+				value.length > 0
+					? theme.fg("text", value)
+					: theme.fg("dim", CUSTOM_INPUT_PLACEHOLDER);
+			const padding =
+				value.length > 0
+					? ""
+					: " ".repeat(
+							Math.max(0, inputWidth - visibleWidth(CUSTOM_INPUT_PLACEHOLDER)),
+						);
+			return [`${prefix}${numberPrefix}${display}${padding}`];
+		}
+
+		function render(width: number): string[] {
+			if (cachedLines) return cachedLines;
+
+			const lines: string[] = [];
+			const renderWidth = Math.max(1, width);
+
+			function addWrapped(text: string) {
+				lines.push(...wrapTextWithAnsi(text, renderWidth));
+			}
+
+			function addWrappedWithPrefix(prefix: string, text: string) {
+				const prefixWidth = visibleWidth(prefix);
+				if (prefixWidth >= renderWidth) {
+					addWrapped(prefix + text);
+					return;
+				}
+				const wrapped = wrapTextWithAnsi(text, renderWidth - prefixWidth);
+				const continuationPrefix = " ".repeat(prefixWidth);
+				for (let i = 0; i < wrapped.length; i++) {
+					lines.push(`${i === 0 ? prefix : continuationPrefix}${wrapped[i]}`);
+				}
+			}
+
+			lines.push(theme.fg("accent", "─".repeat(renderWidth)));
+			addWrappedWithPrefix(" ", theme.fg("text", params.question));
+			lines.push("");
+
+			for (let i = 0; i < options.length; i++) {
+				const opt = options[i];
+				const selected = !isOnCustomInput() && i === optionIndex;
+				const prefix = selected ? theme.fg("accent", "> ") : "  ";
+				const label = `${i + 1}. ${opt.label}`;
+				const color = selected ? "accent" : "text";
+
+				addWrappedWithPrefix(prefix, theme.fg(color, label));
+
+				if (opt.description) {
+					addWrappedWithPrefix("     ", theme.fg("muted", opt.description));
+				}
+			}
+
+			const customSelected = isOnCustomInput();
+			const customPrefix = customSelected ? theme.fg("accent", "> ") : "  ";
+			const customNumber = `${customInputIndex + 1}.`;
+			for (const line of renderCustomInputRow(
+				customPrefix,
+				customNumber,
+				renderWidth,
+				customSelected,
+			)) {
+				addWrapped(line);
+			}
+
+			lines.push("");
+			addWrappedWithPrefix(
+				" ",
+				theme.fg(
+					"dim",
+					"↑↓ select • 1-9 quick pick • Enter confirm • Esc cancel",
+				),
+			);
+			lines.push(theme.fg("accent", "─".repeat(renderWidth)));
+
+			cachedLines = lines;
+			return lines;
+		}
+
+		return {
+			render,
+			invalidate: () => {
+				cachedLines = undefined;
+			},
+			handleInput,
+		};
+	});
+}

package/node_modules/@vitos-pizza/question/src/register-tool.ts

@@ -0,0 +1,224 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { forwardQuestionPrompt } from "./forwarding/forwarder.ts";
+import { isSubagentChild, resolveParentSessionId } from "./parent-session.ts";
+import { runQuestionUi } from "./question-ui.ts";
+import type {
+	QuestionDetails,
+	QuestionParams,
+} from "./types.ts";
+
+const OptionSchema = Type.Object({
+	label: Type.String({ description: "Display label for the option" }),
+	description: Type.Optional(
+		Type.String({ description: "Optional description shown below label" }),
+	),
+});
+
+const QuestionParamsSchema = Type.Object({
+	question: Type.String({ description: "The question to ask the user" }),
+	options: Type.Array(OptionSchema, {
+		description: "Options for the user to choose from",
+	}),
+});
+
+export interface QuestionToolDeps {
+	getAgentDir: () => string;
+	events: {
+		emit(channel: string, payload: unknown): void;
+		on(channel: string, handler: (payload: unknown) => void): () => void;
+	};
+}
+
+function buildCancelledResult(
+	params: QuestionParams,
+): AgentToolResult<QuestionDetails> {
+	const simpleOptions = params.options.map((o) => o.label);
+	return {
+		content: [{ type: "text", text: "User cancelled the selection" }],
+		details: {
+			question: params.question,
+			options: simpleOptions,
+			answer: null,
+		},
+	};
+}
+
+function buildAnswerResult(
+	params: QuestionParams,
+	answer: string,
+	wasCustom: boolean,
+	index?: number,
+): AgentToolResult<QuestionDetails> {
+	const simpleOptions = params.options.map((o) => o.label);
+	if (wasCustom) {
+		return {
+			content: [{ type: "text", text: `User wrote: ${answer}` }],
+			details: {
+				question: params.question,
+				options: simpleOptions,
+				answer,
+				wasCustom: true,
+			},
+		};
+	}
+	return {
+		content: [
+			{
+				type: "text",
+				text: `User selected: ${index ?? simpleOptions.indexOf(answer) + 1}. ${answer}`,
+			},
+		],
+		details: {
+			question: params.question,
+			options: simpleOptions,
+			answer,
+			wasCustom: false,
+		},
+	};
+}
+
+function buildUnavailableResult(
+	params: QuestionParams,
+	reason: string,
+): AgentToolResult<QuestionDetails> {
+	return {
+		content: [{ type: "text", text: reason }],
+		details: {
+			question: params.question,
+			options: params.options.map((o) => o.label),
+			answer: null,
+		},
+	};
+}
+
+async function executeQuestion(
+	params: QuestionParams,
+	ctx: ExtensionContext,
+	deps: QuestionToolDeps,
+): Promise<AgentToolResult<QuestionDetails>> {
+	if (params.options.length === 0) {
+		return buildUnavailableResult(params, "Error: No options provided");
+	}
+
+	const child = isSubagentChild();
+	const parentSessionId = resolveParentSessionId();
+	const currentSessionId = ctx.sessionManager.getSessionId?.() ?? null;
+
+	if (!child && ctx.hasUI) {
+		const result = await runQuestionUi(ctx.ui, params);
+		if (!result) return buildCancelledResult(params);
+		return buildAnswerResult(
+			params,
+			result.answer,
+			result.wasCustom,
+			result.index,
+		);
+	}
+
+	if (!parentSessionId) {
+		return buildUnavailableResult(
+			params,
+			"Error: UI not available (running in non-interactive mode)",
+		);
+	}
+
+	const forwarded = await forwardQuestionPrompt({
+		events: deps.events,
+		agentDir: deps.getAgentDir(),
+		targetSessionId: parentSessionId,
+		requesterSessionId: currentSessionId ?? "unknown",
+		params,
+	});
+
+	if (!forwarded) {
+		return buildUnavailableResult(
+			params,
+			"Error: Question prompt timed out or parent session unavailable",
+		);
+	}
+
+	if (forwarded.cancelled || forwarded.answer === null) {
+		return buildCancelledResult(params);
+	}
+
+	return buildAnswerResult(
+		params,
+		forwarded.answer,
+		forwarded.wasCustom ?? false,
+	);
+}
+
+export function registerQuestionTool(
+	pi: ExtensionAPI,
+	deps: QuestionToolDeps,
+): void {
+	pi.registerTool({
+		name: "question",
+		label: "Question",
+		description:
+			"Ask the user a question and let them pick from options. Use when you need user input to proceed.",
+		parameters: QuestionParamsSchema,
+		executionMode: "sequential",
+
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			return executeQuestion(params, ctx, deps);
+		},
+
+		renderCall(_args, theme, _context) {
+			return new Text(theme.fg("toolTitle", theme.bold("question")), 0, 0);
+		},
+
+		renderResult(result, _options, theme, _context) {
+			const details = result.details as QuestionDetails | undefined;
+			if (!details) {
+				const text = result.content[0];
+				const fallback = text?.type === "text" ? text.text : "";
+				return new Text(fallback, 0, 0);
+			}
+
+			if (details.answer === null) {
+				return new Text(theme.fg("warning", "Cancelled"), 0, 0);
+			}
+
+			return new Text(
+				theme.fg("success", "✓ ") + theme.fg("accent", details.answer),
+				0,
+				0,
+			);
+		},
+	});
+}
+
+export async function promptQuestionLocally(
+	ui: ExtensionContext["ui"],
+	params: QuestionParams,
+	responderSessionId: string,
+) {
+	const simpleOptions = params.options.map((o) => o.label);
+	const result = await runQuestionUi(ui, params);
+	if (!result) {
+		return {
+			question: params.question,
+			options: simpleOptions,
+			answer: null,
+			cancelled: true,
+			responderSessionId,
+			respondedAt: Date.now(),
+		};
+	}
+	return {
+		question: params.question,
+		options: simpleOptions,
+		answer: result.answer,
+		wasCustom: result.wasCustom,
+		cancelled: false,
+		responderSessionId,
+		respondedAt: Date.now(),
+	};
+}

package/node_modules/@vitos-pizza/question/src/types.ts

@@ -0,0 +1,41 @@
+export interface QuestionOption {
+	label: string;
+	description?: string;
+}
+
+export interface QuestionParams {
+	question: string;
+	options: QuestionOption[];
+}
+
+export interface QuestionDetails {
+	question: string;
+	options: string[];
+	answer: string | null;
+	wasCustom?: boolean;
+}
+
+export interface QuestionUiResult {
+	answer: string;
+	wasCustom: boolean;
+	index?: number;
+}
+
+export interface ForwardedQuestionRequest {
+	id: string;
+	createdAt: number;
+	requesterSessionId: string;
+	targetSessionId: string;
+	question: string;
+	options: QuestionOption[];
+}
+
+export interface ForwardedQuestionResponse {
+	question: string;
+	options: string[];
+	answer: string | null;
+	wasCustom?: boolean;
+	cancelled?: boolean;
+	responderSessionId: string;
+	respondedAt: number;
+}

package/node_modules/@vitos-pizza/question/tests/forwarder.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import {
+	QUESTION_RPC_PROMPT,
+	QUESTION_RPC_PROMPT_REPLY_PREFIX,
+	questionReplyChannel,
+} from "../src/forwarding/channels.ts";
+import {
+	forwardQuestionPrompt,
+	startQuestionRpcServer,
+} from "../src/forwarding/forwarder.ts";
+
+describe("question forwarding", () => {
+	it("forwards prompts over the event bus", 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((item) => item !== handler),
+					);
+				};
+			},
+		};
+
+		startQuestionRpcServer(events, async (payload) => ({
+			question: payload.question,
+			options: payload.options.map((o) => o.label),
+			answer: payload.options[0]?.label ?? null,
+			wasCustom: false,
+			cancelled: false,
+			responderSessionId: "parent",
+			respondedAt: Date.now(),
+		}));
+
+		const response = await forwardQuestionPrompt({
+			events,
+			requesterSessionId: "child",
+			targetSessionId: "parent",
+			params: {
+				question: "Which approach?",
+				options: [{ label: "A" }, { label: "B" }],
+			},
+			timeoutMs: 1000,
+		});
+
+		expect(response?.answer).toBe("A");
+		expect(handlers.has(QUESTION_RPC_PROMPT)).toBe(true);
+		expect(
+			[...handlers.keys()].some((key) =>
+				key.startsWith(QUESTION_RPC_PROMPT_REPLY_PREFIX),
+			),
+		).toBe(true);
+		expect(questionReplyChannel("test-id")).toBe(
+			`${QUESTION_RPC_PROMPT_REPLY_PREFIX}test-id`,
+		);
+	});
+});

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

@@ -0,0 +1,29 @@
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	isSubagentChild,
+	resolveParentSessionId,
+	SUBAGENT_CHILD_ENV,
+} from "../src/parent-session.ts";
+
+describe("parent session resolution", () => {
+	const originalEnv = { ...process.env };
+
+	afterEach(() => {
+		process.env = { ...originalEnv };
+	});
+
+	it("detects subagent child env", () => {
+		delete process.env[SUBAGENT_CHILD_ENV];
+		expect(isSubagentChild()).toBe(false);
+		process.env[SUBAGENT_CHILD_ENV] = "1";
+		expect(isSubagentChild()).toBe(true);
+	});
+
+	it("resolves parent session from PI_SUBAGENT_PARENT_SESSION", () => {
+		delete process.env.PI_SUBAGENT_PARENT_SESSION;
+		delete process.env.PI_AGENT_ROUTER_PARENT_SESSION_ID;
+		expect(resolveParentSessionId()).toBeNull();
+		process.env.PI_SUBAGENT_PARENT_SESSION = "parent-abc";
+		expect(resolveParentSessionId()).toBe("parent-abc");
+	});
+});

package/node_modules/@vitos-pizza/question/tests/register-tool-render.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { Text } from "@earendil-works/pi-tui";
+
+function renderCall(theme: { fg: (c: string, t: string) => string; bold: (t: string) => string }) {
+	return new Text(theme.fg("toolTitle", theme.bold("question")), 0, 0);
+}
+
+function renderResult(
+	details: { answer: string | null } | undefined,
+	theme: {
+		fg: (c: string, t: string) => string;
+	},
+) {
+	if (!details) return new Text("", 0, 0);
+	if (details.answer === null) {
+		return new Text(theme.fg("warning", "Cancelled"), 0, 0);
+	}
+	return new Text(
+		theme.fg("success", "✓ ") + theme.fg("accent", details.answer),
+		0,
+		0,
+	);
+}
+
+function textFrom(component: Text): string {
+	return (component.render(120)[0] ?? "").trimEnd();
+}
+
+describe("question render helpers", () => {
+	const theme = {
+		fg: (_color: string, text: string) => text,
+		bold: (text: string) => text,
+	};
+
+	it("renderCall stays minimal without option list", () => {
+		const output = textFrom(renderCall(theme));
+		expect(output).toBe("question");
+		expect(output).not.toContain("Options:");
+	});
+
+	it("renderResult shows a single-line answer", () => {
+		const output = textFrom(renderResult({ answer: "Yes" }, theme));
+		expect(output).toBe("✓ Yes");
+	});
+});

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

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