@vitos-pizza/vitos-pizza 0.1.0

package/package.json

@@ -0,0 +1,90 @@
+{
+	"name": "@vitos-pizza/vitos-pizza",
+	"version": "0.1.0",
+	"description": "Vito's Pizzeria — a Pi distribution (Garfield-approved)",
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org/"
+	},
+	"type": "module",
+	"license": "MIT",
+	"keywords": [
+		"pi-package",
+		"pi",
+		"vitos-pizza"
+	],
+	"workspaces": [
+		"packages/*"
+	],
+	"scripts": {
+		"sync": "node scripts/sync-pi-manifest.mjs",
+		"postinstall": "node scripts/sync-pi-manifest.mjs",
+		"typecheck": "npm run typecheck --workspaces --if-present",
+		"test": "npm run test --workspaces --if-present",
+		"lint": "npm run lint --workspaces --if-present",
+		"lint:fix": "npm run lint:fix --workspaces --if-present",
+		"install:pi": "pi install .",
+		"install:pi:local": "pi install -l .",
+		"try:pi": "pi -e .",
+		"prepack": "node scripts/prepare-publish.mjs prepack",
+		"postpack": "node scripts/prepare-publish.mjs postpack"
+	},
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.14",
+		"typescript": "^5.8.0"
+	},
+	"dependencies": {
+		"@vitos-pizza/agent-mode": "0.1.0",
+		"@vitos-pizza/keybindings": "0.1.0",
+		"@vitos-pizza/permission-system": "0.1.0",
+		"@vitos-pizza/question": "0.1.0",
+		"@vitos-pizza/session-title": "0.1.0",
+		"@vitos-pizza/subagents": "0.1.0",
+		"@vitos-pizza/ui-enhancements": "0.1.0",
+		"@vitos-pizza/websearch": "0.1.0"
+	},
+	"bundledDependencies": [
+		"@vitos-pizza/agent-mode",
+		"@vitos-pizza/keybindings",
+		"@vitos-pizza/permission-system",
+		"@vitos-pizza/question",
+		"@vitos-pizza/session-title",
+		"@vitos-pizza/subagents",
+		"@vitos-pizza/ui-enhancements",
+		"@vitos-pizza/websearch"
+	],
+	"piBundled": [],
+	"pi": {
+		"extensions": [
+			"node_modules/@vitos-pizza/permission-system/extensions",
+			"node_modules/@vitos-pizza/question/extensions",
+			"node_modules/@vitos-pizza/ui-enhancements/extensions",
+			"node_modules/@vitos-pizza/agent-mode/extensions",
+			"node_modules/@vitos-pizza/subagents/extensions",
+			"node_modules/@vitos-pizza/websearch/extensions",
+			"node_modules/@vitos-pizza/session-title/extensions",
+			"node_modules/@vitos-pizza/keybindings/extensions"
+		],
+		"skills": [
+			"node_modules/@vitos-pizza/subagents/skills"
+		]
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/xin2017338/vitos-pizza.git"
+	},
+	"files": [
+		"packages",
+		"assets",
+		"scripts/sync-pi-manifest.mjs",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md",
+		"AGENTS.md",
+		"!packages/**/tests",
+		"!packages/**/node_modules"
+	]
+}

package/packages/agent-mode/extensions/index.ts

@@ -0,0 +1,117 @@
+/**
+ * @vitos-pizza/agent-mode — centralized agent / plan / execute mode switching.
+ */
+
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { emitShortcutAction } from "@vitos-pizza/keybindings/types";
+import {
+	applyAgentMode,
+	createReloadEmitter,
+	ensureAgentModePersisted,
+} from "../src/apply-mode.ts";
+import {
+	clearAgentModeStatus,
+	emitAgentModeChanged,
+	updateAgentModeStatusFallback,
+} from "../src/mode-events.ts";
+import {
+	AGENT_MODES,
+	cycleAgentMode,
+	isAgentMode,
+	MODE_LABELS,
+	type AgentMode,
+} from "../src/modes.ts";
+import {
+	PLAN_INSTRUCTIONS,
+	PLAN_MODE_MESSAGE,
+	PLAN_MODE_TOOLS,
+} from "../src/plan-instructions.ts";
+
+export default function (pi: ExtensionAPI): void {
+	let currentMode: AgentMode = "agent";
+
+	const emitReload = createReloadEmitter(pi.events);
+
+	const publishMode = (ctx: ExtensionContext, mode: AgentMode) => {
+		currentMode = mode;
+		emitAgentModeChanged(pi.events, mode);
+		updateAgentModeStatusFallback(ctx, mode);
+	};
+
+	const switchMode = async (ctx: ExtensionContext, mode: AgentMode) => {
+		applyAgentMode(ctx.cwd, mode, { emitReload: emitReload });
+		publishMode(ctx, mode);
+		ctx.ui.notify(`Mode: ${mode}`, "info");
+	};
+
+	emitShortcutAction(pi.events, {
+		id: "agent-mode.cycle",
+		description: "Cycle agent mode (agent → plan → execute)",
+		handler: async (shortcutCtx) => {
+			const next = cycleAgentMode(currentMode);
+			await switchMode(shortcutCtx, next);
+		},
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		const mode = ensureAgentModePersisted(ctx.cwd, { emitReload });
+		publishMode(ctx, mode);
+	});
+
+	pi.on("session_shutdown", (_event, ctx) => {
+		clearAgentModeStatus(ctx);
+	});
+
+	pi.on("before_agent_start", async (event, _ctx) => {
+		if (currentMode !== "plan") return {};
+
+		const registered = new Set(pi.getAllTools().map((tool) => tool.name));
+		const activeTools = PLAN_MODE_TOOLS.filter((name) => registered.has(name));
+		if (activeTools.length > 0) {
+			pi.setActiveTools([...activeTools]);
+		}
+
+		return {
+			message: {
+				customType: "agent-plan-mode",
+				content: PLAN_MODE_MESSAGE,
+				display: false,
+			},
+			systemPrompt: `${event.systemPrompt}\n\n${PLAN_INSTRUCTIONS}`,
+		};
+	});
+
+	pi.registerCommand("mode", {
+		description: "Switch agent mode (agent|plan|execute)",
+		handler: async (args, ctx) => {
+			const requested = args?.trim().toLowerCase();
+			let mode: AgentMode | undefined;
+
+			if (requested) {
+				if (!isAgentMode(requested)) {
+					ctx.ui.notify(
+						`Unknown mode "${requested}". Use: ${AGENT_MODES.join(", ")}`,
+						"error",
+					);
+					return;
+				}
+				mode = requested;
+			} else if (ctx.hasUI) {
+				const options = AGENT_MODES.map((m) => MODE_LABELS[m]);
+				const selected = await ctx.ui.select("Agent mode", options);
+				if (!selected) return;
+				const index = options.indexOf(selected);
+				if (index < 0) return;
+				mode = AGENT_MODES[index];
+			} else {
+				ctx.ui.notify(`Usage: /mode <${AGENT_MODES.join("|")}>`, "info");
+				return;
+			}
+
+			await switchMode(ctx, mode);
+		},
+	});
+}

package/packages/agent-mode/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "@vitos-pizza/agent-mode",
+	"version": "0.1.0",
+	"description": "Centralized agent / plan / execute mode switching for Vito's Pizzeria",
+	"type": "module",
+	"license": "MIT",
+	"private": true,
+	"scripts": {
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write ."
+	},
+	"dependencies": {
+		"@vitos-pizza/keybindings": "0.1.0",
+		"@vitos-pizza/permission-system": "0.1.0"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*"
+	},
+	"pi": {
+		"requires": [
+			"@vitos-pizza/permission-system"
+		]
+	},
+	"devDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"vitest": "^3.2.4"
+	}
+}

package/packages/agent-mode/src/apply-mode.ts

@@ -0,0 +1,60 @@
+import {
+	applyPermissionPreset,
+	loadProjectConfig,
+	PERMISSION_RELOAD_CONFIG_EVENT,
+	saveProjectConfig,
+} from "@vitos-pizza/permission-system/mode-api";
+import {
+	inferAgentMode,
+	PRESET_BY_MODE,
+	type AgentMode,
+} from "./modes.ts";
+
+export interface ApplyAgentModeDeps {
+	emitReload: () => void;
+}
+
+export function applyAgentMode(
+	cwd: string,
+	mode: AgentMode,
+	deps?: ApplyAgentModeDeps,
+): AgentMode {
+	const preset = PRESET_BY_MODE[mode];
+	applyPermissionPreset(cwd, preset);
+	const existing = loadProjectConfig(cwd);
+	const next = {
+		...existing,
+		agentMode: mode,
+		yoloMode: false,
+	};
+	saveProjectConfig(cwd, next);
+	deps?.emitReload();
+	return mode;
+}
+
+export function resolveCurrentAgentMode(cwd: string): AgentMode {
+	const config = loadProjectConfig(cwd);
+	return inferAgentMode(config);
+}
+
+export function ensureAgentModePersisted(
+	cwd: string,
+	deps?: ApplyAgentModeDeps,
+): AgentMode {
+	const config = loadProjectConfig(cwd);
+	const mode = inferAgentMode(config);
+	if (config.agentMode !== mode) {
+		applyAgentMode(cwd, mode, deps);
+		return mode;
+	}
+	deps?.emitReload();
+	return mode;
+}
+
+export function createReloadEmitter(
+	events: { emit: (channel: string, payload: unknown) => void },
+): () => void {
+	return () => {
+		events.emit(PERMISSION_RELOAD_CONFIG_EVENT, {});
+	};
+}

package/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/keybindings/presets/shortcuts.json

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