@vitos-pizza/vitos-pizza 0.2.0 → 0.3.0

package/packages/ui-enhancements/src/chrome/execute-prompt.ts

@@ -0,0 +1,83 @@
+import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+
+export const EXECUTE_START_MESSAGE = "开始实现";
+export const EXECUTE_ACTION_LABEL = "开始实现";
+
+export type ExecutePromptFocus = "action" | "editor";
+
+export type ExecutePromptTheme = {
+	fg(color: string, text: string): string;
+};
+
+export type ExecutePromptKeyResult =
+	| { type: "setFocus"; focus: ExecutePromptFocus }
+	| { type: "submitStart" }
+	| { type: "delegate" };
+
+export function formatExecuteActionLine(
+	selected: boolean,
+	theme: ExecutePromptTheme,
+	_width: number,
+): string {
+	const label = theme.fg(selected ? "accent" : "dim", EXECUTE_ACTION_LABEL);
+	if (selected) {
+		return `${theme.fg("accent", "▶ ")}${label}`;
+	}
+	return label;
+}
+
+/** Light dotted rule — avoids competing with the full-width border chrome. */
+export function formatExecuteSeparatorLine(
+	theme: ExecutePromptTheme,
+	width: number,
+): string {
+	const unit = "· ";
+	const count = Math.max(0, Math.floor(width / visibleWidth(unit)));
+	const dots = unit.repeat(count).trimEnd();
+	return theme.fg("dim", dots);
+}
+
+/**
+ * Decide how execute-mode prompt UI should handle a key when it owns focus logic.
+ * Returns `delegate` for keys the underlying CustomEditor should handle
+ * (shortcuts, free-text editing, etc.).
+ */
+export function handleExecutePromptKey(
+	focus: ExecutePromptFocus,
+	data: string,
+	options: { editorEmpty: boolean; onFirstVisualLine: boolean },
+): ExecutePromptKeyResult {
+	if (focus === "action") {
+		if (matchesKey(data, Key.down)) {
+			return { type: "setFocus", focus: "editor" };
+		}
+		if (matchesKey(data, Key.up)) {
+			return { type: "setFocus", focus: "action" };
+		}
+		if (matchesKey(data, Key.enter)) {
+			return { type: "submitStart" };
+		}
+		return { type: "delegate" };
+	}
+
+	if (
+		matchesKey(data, Key.up) &&
+		options.editorEmpty &&
+		options.onFirstVisualLine
+	) {
+		return { type: "setFocus", focus: "action" };
+	}
+	return { type: "delegate" };
+}
+
+/** Insert action + separator after the top border, before the editor body. */
+export function injectExecutePromptRows(
+	lines: string[],
+	actionLine: string,
+	separatorLine: string,
+): string[] {
+	if (lines.length < 2) return lines;
+	const next = [...lines];
+	next.splice(1, 0, actionLine, separatorLine);
+	return next;
+}

package/packages/websearch/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/websearch",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "Web search and URL reading for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",

package/scripts/sync-pi-manifest.mjs

@@ -10,7 +10,7 @@ const RESOURCE_TYPES = ["extensions", "skills", "prompts", "themes"];
 
 const BUNDLED_FIRST = [];
 const BUNDLED_LAST = [];
-const LOCAL_ORDER = ["permission-system", "question", "ui-enhancements", "agent-mode", "subagents", "websearch", "session-title", "todoist", "keybindings"];
+const LOCAL_ORDER = ["permission-system", "settings-preset", "question", "ui-enhancements", "agent-mode", "subagents", "websearch", "session-title", "todoist", "keybindings"];
 
 function loadJson(path) {
 	return JSON.parse(readFileSync(path, "utf8"));

package/node_modules/@vitos-pizza/agent-mode/extensions/index.ts

@@ -1,138 +0,0 @@
-/**
- * @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_ENDED_MESSAGE,
-	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 allToolNames = () => pi.getAllTools().map((tool) => tool.name);
-
-	const publishMode = (ctx: ExtensionContext, mode: AgentMode) => {
-		currentMode = mode;
-		emitAgentModeChanged(pi.events, mode);
-		updateAgentModeStatusFallback(ctx, mode);
-	};
-
-	const switchMode = async (ctx: ExtensionContext, mode: AgentMode) => {
-		const leavingPlan = currentMode === "plan" && mode !== "plan";
-		applyAgentMode(ctx.cwd, mode, { emitReload: emitReload });
-		publishMode(ctx, mode);
-		if (leavingPlan) {
-			const tools = allToolNames();
-			if (tools.length > 0) {
-				pi.setActiveTools(tools);
-			}
-			pi.sendMessage({
-				customType: "agent-plan-mode-ended",
-				content: PLAN_MODE_ENDED_MESSAGE,
-				display: false,
-			});
-		}
-		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") {
-			const tools = allToolNames();
-			if (tools.length > 0) {
-				pi.setActiveTools(tools);
-			}
-			return {};
-		}
-
-		const registered = new Set(allToolNames());
-		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/node_modules/@vitos-pizza/agent-mode/package.json

@@ -1,31 +0,0 @@
-{
-	"name": "@vitos-pizza/agent-mode",
-	"version": "0.2.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.2.0",
-		"@vitos-pizza/permission-system": "0.2.0"
-	},
-	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": "*"
-	},
-	"pi": {
-		"requires": [
-			"@vitos-pizza/permission-system"
-		]
-	},
-	"devDependencies": {
-		"@earendil-works/pi-coding-agent": "*",
-		"vitest": "^3.2.4"
-	}
-}

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

@@ -1,60 +0,0 @@
-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/node_modules/@vitos-pizza/agent-mode/src/mode-events.ts

@@ -1,102 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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**
-- Mutually exclusive design choices (2–5 options) → always use the \`question\` tool; do not ask in free text
-- Produce an Implementation Plan and wait for user confirmation
-- Do **not** call worker or edit code directly in this mode
-
-**When to explore**
-- Scout is **optional**. Skip it when the task is clear, scoped to known files, or the user already provided enough context
-- Call scout only when you need codebase recon (unfamiliar area, many files, unclear entry points)
-- Independent areas → parallel scouts via \`subagent({ tasks: [...] })\` to finish recon faster; then planner
-- For light lookups, the main agent may use read/grep/find/ls directly — no scout required
-
-**Delegation**
-- Enough context already → \`subagent({ agent: "planner", task: "..." })\`
-- Need recon first → \`subagent({ chain: [{ agent: "scout", task: "..." }, { agent: "planner", task: "..." }] })\`
-- Multi-area recon → parallel scouts, then planner with the combined findings
-
-**After the plan (optional)**
-When helpful, add a short **Next** footer — Cursor-style suggested actions. Skip it if the next step is already obvious.
-- 2–3 bullets max; each one line
-- Concrete verbs the user can reply with (e.g. confirm → \`/mode execute\`, tweak scope)
-- No essays, no restating the whole plan
-
-Example:
-\`\`\`
-**Next**
-- Confirm → \`/mode execute\` (or F6) to implement
-- Say what to change if the scope is off
-\`\`\`
-
-**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.
-
-1. Mutually exclusive choices → \`question\` tool (not free-text "which do you prefer?")
-2. Scout only if needed; parallel scouts (\`tasks: [...]\`) when exploring independent areas; otherwise go straight to planner
-3. Return the plan and wait; optionally a short **Next** footer (2–3 one-line actions) when helpful
-4. Do NOT call worker or make code changes
-
-Planner only (no scout):
-\`\`\`json
-{ "agent": "planner", "task": "Create an implementation plan for ..." }
-\`\`\`
-
-Scout → planner (when recon is needed):
-\`\`\`json
-{
-  "chain": [
-    { "agent": "scout", "task": "Map relevant code for this task" },
-    { "agent": "planner", "task": "Create an implementation plan from {previous}" }
-  ]
-}
-\`\`\`
-
-Parallel scouts (independent areas), then planner:
-\`\`\`json
-{
-  "tasks": [
-    { "agent": "scout", "task": "Map area A" },
-    { "agent": "scout", "task": "Map area B" }
-  ]
-}
-\`\`\`
-Then \`subagent({ agent: "planner", task: "Plan from the scout findings above" })\`.`;
-
-export const PLAN_MODE_ENDED_MESSAGE = `[PLAN MODE ENDED]
-
-You left plan mode. write, edit, and bash are available again according to the current mode (agent or execute). Do not treat earlier [PLAN MODE ACTIVE] messages as still in effect.`;

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

@@ -1,36 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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");
-	});
-});