@vitos-pizza/vitos-pizza 0.1.0

package/node_modules/@vitos-pizza/agent-mode/src/mode-events.ts

@@ -0,0 +1,102 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentMode } from "./modes.ts";
+
+export const AGENT_MODE_CHANGED = "agent-mode:changed";
+export const AGENT_MODE_STATUS_KEY = "agent-mode";
+
+export type AgentModeDisplayColor = "dim" | "accent" | "warning";
+
+export interface AgentModeChangedPayload {
+	mode: AgentMode;
+	label: string;
+	color: AgentModeDisplayColor;
+}
+
+interface EventBus {
+	emit(channel: string, payload: unknown): void;
+}
+
+function modeDisplay(mode: AgentMode): AgentModeChangedPayload {
+	switch (mode) {
+		case "plan":
+			return { mode, label: "plan", color: "accent" };
+		case "execute":
+			return { mode, label: "execute", color: "warning" };
+		default:
+			return { mode, label: "agent", color: "dim" };
+	}
+}
+
+export function formatAgentModeStatusText(mode: AgentMode): string {
+	return `mode: ${mode}`;
+}
+
+export function emitAgentModeChanged(
+	events: EventBus,
+	mode: AgentMode,
+): AgentModeChangedPayload {
+	const payload = modeDisplay(mode);
+	events.emit(AGENT_MODE_CHANGED, payload);
+	return payload;
+}
+
+function isBorderStatusBarEnabled(cwd: string): boolean {
+	let borderStatusBar = true;
+	const globalPath = join(homedir(), ".pi", "agent", "settings.json");
+	const projectPath = join(cwd, ".pi", "settings.json");
+
+	for (const path of [globalPath, projectPath]) {
+		if (!existsSync(path)) continue;
+		try {
+			const raw = JSON.parse(readFileSync(path, "utf8")) as {
+				ui?: { borderStatusBar?: boolean };
+			};
+			if (typeof raw.ui?.borderStatusBar === "boolean") {
+				borderStatusBar = raw.ui.borderStatusBar;
+			}
+		} catch {
+			// ignore invalid settings
+		}
+	}
+
+	return borderStatusBar;
+}
+
+export function updateAgentModeStatusFallback(
+	ctx: ExtensionContext,
+	mode: AgentMode,
+): void {
+	if (!ctx.hasUI || ctx.mode !== "tui") return;
+	if (isBorderStatusBarEnabled(ctx.cwd)) {
+		ctx.ui.setStatus(AGENT_MODE_STATUS_KEY, undefined);
+		return;
+	}
+	const theme = ctx.ui.theme;
+	const display = modeDisplay(mode);
+	const text = theme.fg(display.color, formatAgentModeStatusText(mode));
+	ctx.ui.setStatus(AGENT_MODE_STATUS_KEY, text);
+}
+
+export function clearAgentModeStatus(ctx: ExtensionContext): void {
+	if (!ctx.hasUI) return;
+	ctx.ui.setStatus(AGENT_MODE_STATUS_KEY, undefined);
+}
+
+export function isAgentModeChangedPayload(
+	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")
+	);
+}

package/node_modules/@vitos-pizza/agent-mode/src/modes.ts

@@ -0,0 +1,43 @@
+import type { PermissionPresetName } from "@vitos-pizza/permission-system/mode-api";
+import {
+	PRESETS_DIR,
+} from "@vitos-pizza/permission-system/mode-api";
+import { detectPresetMode } from "@vitos-pizza/permission-system/detect-preset-mode";
+import type { ExtensionConfig } from "@vitos-pizza/permission-system/types";
+
+export type AgentMode = "agent" | "plan" | "execute";
+
+export const AGENT_MODES: readonly AgentMode[] = [
+	"agent",
+	"plan",
+	"execute",
+] as const;
+
+export const PRESET_BY_MODE: Record<AgentMode, PermissionPresetName> = {
+	agent: "default",
+	plan: "plan",
+	execute: "yolo",
+};
+
+export const MODE_LABELS: Record<AgentMode, string> = {
+	agent: "Agent mode — balanced permissions",
+	plan: "Plan mode — read-only exploration",
+	execute: "Execute mode — minimal gates",
+};
+
+export function isAgentMode(value: string): value is AgentMode {
+	return (AGENT_MODES as readonly string[]).includes(value);
+}
+
+export function cycleAgentMode(current: AgentMode): AgentMode {
+	const index = AGENT_MODES.indexOf(current);
+	return AGENT_MODES[(index + 1) % AGENT_MODES.length];
+}
+
+export function inferAgentMode(config: ExtensionConfig): AgentMode {
+	if (config.agentMode) return config.agentMode;
+	const detected = detectPresetMode(config.permission, PRESETS_DIR);
+	if (detected === "plan") return "plan";
+	if (detected === "yolo") return "execute";
+	return "agent";
+}

package/node_modules/@vitos-pizza/agent-mode/src/plan-instructions.ts

@@ -0,0 +1,44 @@
+export const PLAN_MODE_TOOLS = [
+	"read",
+	"grep",
+	"find",
+	"ls",
+	"question",
+	"subagent",
+	"wait",
+	"web_search",
+	"web_read",
+] as const;
+
+export const PLAN_INSTRUCTIONS = `## PLAN MODE
+
+You are in **plan** mode. Do not call write, edit, or bash on the main agent.
+
+**Planning workflow**
+- Default path: \`subagent({ chain: [{ agent: "scout", task: "..." }, { agent: "planner", task: "..." }] })\`
+- Use the \`question\` tool when requirements are unclear
+- Produce an Implementation Plan and wait for user confirmation
+- Do **not** call worker or edit code directly in this mode
+
+**To implement**, the user must switch to execute or agent mode (\`/mode execute\` or \`/mode agent\`).`;
+
+export const PLAN_MODE_MESSAGE = `[PLAN MODE ACTIVE]
+
+You are in plan mode. The main agent must NOT write, edit, or run bash.
+
+For any task that needs codebase exploration or an implementation plan, you MUST delegate to subagents:
+
+1. Call \`subagent\` with a scout → planner chain (do not only use read/grep yourself)
+2. Use \`question\` when requirements are unclear
+3. Return the planner's output and wait for user confirmation
+4. Do NOT call worker or make code changes
+
+Example:
+\`\`\`json
+{
+  "chain": [
+    { "agent": "scout", "task": "Map relevant code for this task" },
+    { "agent": "planner", "task": "Create an implementation plan from {previous}" }
+  ]
+}
+\`\`\``;

package/node_modules/@vitos-pizza/agent-mode/tests/apply-mode.test.ts

@@ -0,0 +1,36 @@
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { loadProjectConfig } from "@vitos-pizza/permission-system/mode-api";
+import { applyAgentMode } from "../src/apply-mode.ts";
+
+describe("apply-mode", () => {
+	it("persists agentMode and matching preset", () => {
+		const cwd = mkdtempSync(join(tmpdir(), "agent-mode-"));
+		applyAgentMode(cwd, "plan");
+		const config = loadProjectConfig(cwd);
+		expect(config.agentMode).toBe("plan");
+		expect(config.permission?.write).toBe("deny");
+		expect(config.yoloMode).toBe(false);
+	});
+
+	it("writes execute mode with yolo preset permissions", () => {
+		const cwd = mkdtempSync(join(tmpdir(), "agent-mode-"));
+		applyAgentMode(cwd, "execute");
+		const config = loadProjectConfig(cwd);
+		expect(config.agentMode).toBe("execute");
+		expect(config.permission?.bash).toEqual({
+			"*": "allow",
+			"rm -rf *": "deny",
+		});
+
+		const raw = JSON.parse(
+			readFileSync(
+				join(cwd, ".pi", "extensions", "pi-permission-system", "config.json"),
+				"utf8",
+			),
+		) as { agentMode?: string };
+		expect(raw.agentMode).toBe("execute");
+	});
+});

package/node_modules/@vitos-pizza/agent-mode/tests/mode-events.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import {
+	formatAgentModeStatusText,
+	isAgentModeChangedPayload,
+} from "../src/mode-events.ts";
+
+describe("mode-events", () => {
+	it("formats status text", () => {
+		expect(formatAgentModeStatusText("plan")).toBe("mode: plan");
+	});
+
+	it("validates changed payloads", () => {
+		expect(
+			isAgentModeChangedPayload({
+				mode: "execute",
+				label: "execute",
+				color: "warning",
+			}),
+		).toBe(true);
+		expect(isAgentModeChangedPayload({ mode: "bad" })).toBe(false);
+	});
+});

package/node_modules/@vitos-pizza/agent-mode/tests/modes.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import {
+	AGENT_MODES,
+	cycleAgentMode,
+	inferAgentMode,
+	isAgentMode,
+	PRESET_BY_MODE,
+} from "../src/modes.ts";
+
+describe("modes", () => {
+	it("cycles agent → plan → execute → agent", () => {
+		expect(cycleAgentMode("agent")).toBe("plan");
+		expect(cycleAgentMode("plan")).toBe("execute");
+		expect(cycleAgentMode("execute")).toBe("agent");
+	});
+
+	it("maps modes to permission presets", () => {
+		expect(PRESET_BY_MODE.agent).toBe("default");
+		expect(PRESET_BY_MODE.plan).toBe("plan");
+		expect(PRESET_BY_MODE.execute).toBe("yolo");
+	});
+
+	it("validates agent mode strings", () => {
+		for (const mode of AGENT_MODES) {
+			expect(isAgentMode(mode)).toBe(true);
+		}
+		expect(isAgentMode("careful")).toBe(false);
+	});
+
+	it("prefers persisted agentMode over preset detection", () => {
+		expect(
+			inferAgentMode({
+				agentMode: "agent",
+				permission: { "*": "deny" },
+			}),
+		).toBe("agent");
+	});
+});

package/node_modules/@vitos-pizza/agent-mode/tests/plan-instructions.test.ts

@@ -0,0 +1,45 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { PermissionEvaluator } from "../../permission-system/src/permission-evaluator.ts";
+import { sanitizeSkillPromptBlocks } from "../../permission-system/src/sanitizers/skill-prompt.ts";
+import { PLAN_MODE_TOOLS } from "../src/plan-instructions.ts";
+
+const presetsDir = join(
+	dirname(fileURLToPath(import.meta.url)),
+	"../../permission-system/presets",
+);
+
+describe("plan-instructions", () => {
+	it("lists subagent tooling for plan mode", () => {
+		expect(PLAN_MODE_TOOLS).toContain("subagent");
+		expect(PLAN_MODE_TOOLS).toContain("question");
+		expect(PLAN_MODE_TOOLS).toContain("web_search");
+		expect(PLAN_MODE_TOOLS).toContain("web_read");
+	});
+
+	it("plan preset keeps subagents skill in the system prompt", () => {
+		const planPreset = JSON.parse(
+			readFileSync(join(presetsDir, "plan.json"), "utf8"),
+		) as { permission: Record<string, unknown> };
+
+		const prompt = [
+			"# System",
+			"",
+			"## Skill: subagents",
+			"Use scout and planner.",
+		].join("\n");
+
+		const evaluator = new PermissionEvaluator();
+		const result = sanitizeSkillPromptBlocks(
+			prompt,
+			planPreset.permission as never,
+			evaluator,
+			{},
+		);
+
+		expect(result.prompt).toContain("## Skill: subagents");
+		expect(result.entries).toHaveLength(1);
+	});
+});

package/node_modules/@vitos-pizza/agent-mode/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/agent-mode/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/keybindings/extensions/index.ts

@@ -0,0 +1,104 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { type BindResult, bindShortcuts } from "../src/bind.ts";
+import {
+	loadShortcutConfigFiles,
+	resolveShortcutConfigPaths,
+} from "../src/config.ts";
+import { ActionRegistry } from "../src/registry.ts";
+import {
+	isShortcutAction,
+	SHORTCUTS_REGISTER,
+	type ShortcutActionEntry,
+} from "../src/types.ts";
+
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const presetPath = join(moduleDir, "..", "presets", "shortcuts.json");
+
+export interface KeybindingsState {
+	entries: ShortcutActionEntry[];
+	bindResult: BindResult;
+	configPaths: ReturnType<typeof resolveShortcutConfigPaths>;
+}
+
+function formatEntriesMessage(state: KeybindingsState): string {
+	if (state.entries.length === 0) {
+		return "No vitos shortcut actions registered yet.\n\nModules can register actions via vitos:shortcuts:register during session_start.";
+	}
+
+	const lines = ["**Action** | **Keys** | **Source**", "--- | --- | ---"];
+
+	for (const entry of state.entries) {
+		const keys =
+			entry.keys.length > 0
+				? entry.keys.map((key) => `\`${key}\``).join(", ")
+				: "_(unbound)_";
+		const source = entry.source ?? "—";
+		lines.push(`\`${entry.id}\` — ${entry.description} | ${keys} | ${source}`);
+	}
+
+	if (state.bindResult.skipped.length > 0) {
+		lines.push("");
+		lines.push("**Skipped bindings:**");
+		for (const skipped of state.bindResult.skipped) {
+			lines.push(
+				`- \`${skipped.actionId}\` \`${skipped.key}\`: ${skipped.reason}`,
+			);
+		}
+	}
+
+	lines.push("");
+	lines.push("Config files (project overrides global overrides preset):");
+	lines.push(`- preset: \`${state.configPaths.presetPath}\``);
+	lines.push(`- global: \`${state.configPaths.globalPath}\``);
+	lines.push(`- project: \`${state.configPaths.projectPath}\``);
+
+	return lines.join("\n");
+}
+
+export function registerKeybindings(pi: ExtensionAPI): {
+	registry: ActionRegistry;
+	getState: () => KeybindingsState | null;
+} {
+	const registry = new ActionRegistry();
+	let state: KeybindingsState | null = null;
+
+	const unsubRegister = pi.events.on(SHORTCUTS_REGISTER, (payload) => {
+		if (!isShortcutAction(payload)) return;
+		registry.register(payload);
+	});
+	void unsubRegister;
+
+	const rebind = (cwd: string) => {
+		const agentDir = getAgentDir();
+		const configPaths = resolveShortcutConfigPaths(presetPath, agentDir, cwd);
+		const config = loadShortcutConfigFiles(configPaths);
+		const bindResult = bindShortcuts(pi, registry, config);
+		const entries = registry.buildEntries(config.bindings);
+		state = { entries, bindResult, configPaths };
+		return state;
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		rebind(ctx.cwd);
+	});
+
+	pi.registerCommand("vitos-shortcuts", {
+		description: "List vitos-pizza shortcut actions and key bindings",
+		handler: async (_args, ctx) => {
+			const current = rebind(ctx.cwd);
+			ctx.ui.notify(formatEntriesMessage(current), "info");
+		},
+	});
+
+	return {
+		registry,
+		getState: () => state,
+	};
+}
+
+export default function (pi: ExtensionAPI): void {
+	registerKeybindings(pi);
+}

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

@@ -0,0 +1,26 @@
+{
+	"name": "@vitos-pizza/keybindings",
+	"version": "0.1.0",
+	"description": "Centralized keyboard shortcut registry for Vito's Pizzeria Pi distribution",
+	"type": "module",
+	"license": "MIT",
+	"private": true,
+	"exports": {
+		"./types": "./src/types.ts"
+	},
+	"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": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"vitest": "^3.2.4"
+	}
+}

package/node_modules/@vitos-pizza/keybindings/presets/shortcuts.json

@@ -0,0 +1,3 @@
+{
+	"agent-mode.cycle": "f6"
+}

package/node_modules/@vitos-pizza/keybindings/src/bind.ts

@@ -0,0 +1,57 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { KeyId } from "@earendil-works/pi-tui";
+import type { ActionRegistry } from "./registry.ts";
+import type { MergedShortcutConfig } from "./types.ts";
+
+export interface BindResult {
+	bound: Array<{ actionId: string; key: KeyId; description: string }>;
+	skipped: Array<{ actionId: string; key: KeyId; reason: string }>;
+	unboundActions: string[];
+}
+
+export function bindShortcuts(
+	pi: Pick<ExtensionAPI, "registerShortcut">,
+	registry: ActionRegistry,
+	config: MergedShortcutConfig,
+): BindResult {
+	const result: BindResult = {
+		bound: [],
+		skipped: [],
+		unboundActions: [],
+	};
+
+	const boundKeys = new Set<string>();
+
+	for (const action of registry.list()) {
+		const binding = config.bindings.get(action.id);
+		if (!binding || binding.keys.length === 0) {
+			result.unboundActions.push(action.id);
+			continue;
+		}
+
+		for (const key of binding.keys) {
+			const normalizedKey = key.toLowerCase();
+			if (boundKeys.has(normalizedKey)) {
+				result.skipped.push({
+					actionId: action.id,
+					key,
+					reason: "duplicate key in vitos-shortcuts config",
+				});
+				continue;
+			}
+
+			pi.registerShortcut(key, {
+				description: action.description,
+				handler: action.handler,
+			});
+			boundKeys.add(normalizedKey);
+			result.bound.push({
+				actionId: action.id,
+				key,
+				description: action.description,
+			});
+		}
+	}
+
+	return result;
+}

package/node_modules/@vitos-pizza/keybindings/src/config.ts

@@ -0,0 +1,84 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+import type { KeyId } from "@earendil-works/pi-tui";
+import type {
+	MergedShortcutConfig,
+	ResolvedShortcutBinding,
+	ShortcutBindingSource,
+	ShortcutBindingsConfig,
+} from "./types.ts";
+
+function loadJsonConfig(path: string): ShortcutBindingsConfig {
+	if (!existsSync(path)) return {};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+			return {};
+		}
+		return parsed as ShortcutBindingsConfig;
+	} catch {
+		return {};
+	}
+}
+
+function normalizeKeys(value: KeyId | KeyId[] | undefined): KeyId[] {
+	if (value === undefined) return [];
+	return Array.isArray(value) ? value : [value];
+}
+
+function mergeLayer(
+	current: Map<string, ResolvedShortcutBinding>,
+	layer: ShortcutBindingsConfig,
+	source: ShortcutBindingSource,
+): Map<string, ResolvedShortcutBinding> {
+	const next = new Map(current);
+	for (const [actionId, keys] of Object.entries(layer)) {
+		const normalized = normalizeKeys(keys);
+		if (normalized.length === 0) {
+			next.delete(actionId);
+			continue;
+		}
+		next.set(actionId, { actionId, keys: normalized, source });
+	}
+	return next;
+}
+
+export function mergeShortcutConfigs(
+	preset: ShortcutBindingsConfig,
+	global: ShortcutBindingsConfig,
+	project: ShortcutBindingsConfig,
+): MergedShortcutConfig {
+	let bindings = new Map<string, ResolvedShortcutBinding>();
+	bindings = mergeLayer(bindings, preset, "preset");
+	bindings = mergeLayer(bindings, global, "global");
+	bindings = mergeLayer(bindings, project, "project");
+	return { bindings };
+}
+
+export function loadShortcutConfigFiles(paths: {
+	presetPath: string;
+	globalPath: string;
+	projectPath: string;
+}): MergedShortcutConfig {
+	const preset = loadJsonConfig(paths.presetPath);
+	const global = loadJsonConfig(paths.globalPath);
+	const project = loadJsonConfig(paths.projectPath);
+	return mergeShortcutConfigs(preset, global, project);
+}
+
+export function resolveShortcutConfigPaths(
+	presetPath: string,
+	agentDir: string,
+	cwd: string,
+): {
+	presetPath: string;
+	globalPath: string;
+	projectPath: string;
+} {
+	return {
+		presetPath,
+		globalPath: join(agentDir, "vitos-shortcuts.json"),
+		projectPath: join(cwd, CONFIG_DIR_NAME, "vitos-shortcuts.json"),
+	};
+}

package/node_modules/@vitos-pizza/keybindings/src/registry.ts

@@ -0,0 +1,43 @@
+import type { ShortcutAction, ShortcutActionEntry } from "./types.ts";
+
+export class ActionRegistry {
+	private actions = new Map<string, ShortcutAction>();
+
+	register(action: ShortcutAction): void {
+		this.actions.set(action.id, action);
+	}
+
+	get(actionId: string): ShortcutAction | undefined {
+		return this.actions.get(actionId);
+	}
+
+	list(): ShortcutAction[] {
+		return [...this.actions.values()].sort((a, b) => a.id.localeCompare(b.id));
+	}
+
+	clear(): void {
+		this.actions.clear();
+	}
+
+	buildEntries(
+		bindings: Map<
+			string,
+			{
+				keys: import("@earendil-works/pi-tui").KeyId[];
+				source?: ShortcutActionEntry["source"];
+			}
+		>,
+	): ShortcutActionEntry[] {
+		const entries: ShortcutActionEntry[] = [];
+		for (const action of this.list()) {
+			const binding = bindings.get(action.id);
+			entries.push({
+				id: action.id,
+				description: action.description,
+				keys: binding?.keys ?? [],
+				source: binding?.source,
+			});
+		}
+		return entries;
+	}
+}