@tomsun28/pizza 0.0.9 → 0.1.1

package/README.md

@@ -1,158 +1,35 @@
-# 🍕 Pizza
+# Pizza
 
-> **CLI display for pi**
+Pizza is an event-driven agent. Every conversation, tool call, and file edit is an event in an immutable log. Your UI, the LLM context, and the session tree are all projections of that log.
 
-Pizza is a command-line AI assistant that displays pi's native tool calls in a clean `[CLI]` tag format. Built on top of [pi-coding-agent](https://github.com/badlogic/pi-coding-agent), it provides developers with an efficient terminal interaction experience.
+[简体中文](./README.zh-CN.md)
 
----
+## About It
 
-## Features
+Pizza is named after Pi -> Pizza. Thanks to Pi for open sourcing.
 
-- **[CLI] Display Format** — Tool calls are displayed in clean [CLI] tag format instead of raw JSON
-- **Interactive TUI** — Beautiful terminal interface based on pi-tui with keyboard shortcuts
-- **Multi-Model Support** — Compatible with OpenAI, Anthropic, and other LLM providers
-- **Session Management** — Automatic saving and management of conversation history
+- **Reactor-driven turn cycle**
+  Unlike `Pi, Claude Code, and Codex`, Pizza does not run the agent loop as a brittle `while true` loop. Each turn is a state machine driven by an event-handler table. The result: interrupts, retries, parallel tool calls, and mid-turn failures can all be handled reliably.
 
----
+- **The log is the single source of truth**
+  Every message, model call, tool result, and file change is written to an immutable `EventStore` (SQLite). The UI, the LLM context, and the session tree are all live projections of that log. State is no longer hidden in mutable objects — it can be rebuilt, audited, and replayed, because the log is the single source of truth.
 
-## Installation
+- **Only one execution tool — the CLI**
+  JSON is program-friendly at the API level but not model-friendly. Pizza aggressively gives the model only one tool: the `CLI Tool`. The model uses it to call `read`, `write`, `edit`, and other command-line commands. Surprisingly, it performs better and is more stable.
 
-```bash
-npm install -g @tomsun28/pizza
-```
+- **Why New Session**
+  In Pizza, you do not need to manually create a new session. Think of it as a long-term task for a friend you can chat with for ten years. A friend will manage their own context — not through compression.
 
----
+- **All interfaces share the same runtime**
+  The interactive TUI, JSON-RPC server, and one-shot print mode all consume the same `SessionFacade` event stream. Script it, embed it, or chat with it directly in the terminal — it is the same agent.
 
-## Usage
+- **Git log-like branch tree memory**
+  Sessions can fork from any earlier message. Rewind, branch, compare. Restart your life anytime, anywhere.
 
-### Start
+## Quick Start
 
 ```bash
-# Interactive mode
+npm install -g pizza
+export ZAI_API_KEY=your_zai_api_key
 pizza
-
-# Execute a single command
-pizza "analyze the current project structure"
-```
-
-### Command Line Options
-
-```
-pizza [options] [message]
-
-OPTIONS:
-  --provider <name>       LLM provider (reads from config by default)
-  -m, --model <id>        Model ID
-  -p, --print             Print mode (non-interactive, single-shot)
-  -h, --help              Show help information
-```
-
-### Keyboard Shortcuts
-
-| Shortcut | Function |
-|----------|----------|
-| `Ctrl+P` | Switch model |
-| `Ctrl+T` | Think mode |
-| `Ctrl+C` | Stop current operation |
-
-### In-Session Commands
-
-- `/cli-mode` — Toggle CLI tag mode (enabled by default)
-- `/help` — Show help
-
----
-
-## [CLI] Display Format
-
-Pizza displays pi's native tool calls in a clean `[CLI]` tag format for better readability:
-
-### Display Format
-
-When the model calls tools, they are displayed as:
-
-```
-[CLI] read package.json[/CLI]
-[CLI] bash node --version[/CLI]
 ```
-
-### Result Display
-
-Tool results are displayed as:
-
-```
-[RESULT]
-{
-  "name": "pizza",
-  "version": "0.0.9"
-}
-[/RESULT]
-```
-
-### Supported Tools
-
-Pizza uses pi's built-in tools:
-
-| Tool | Description |
-|------|-------------|
-| `read` | Read file contents |
-| `write` | Write to a file |
-| `edit` | Edit a file by replacing text |
-| `bash` | Execute shell commands |
-
----
-
-## Development
-
-### Project Structure
-
-```
-.
-├── src/
-│   ├── main.ts           # Entry file
-│   └── extension/
-│       └── index.ts      # Extension main logic (CLI display formatting)
-├── themes/
-│   └── pizza.json        # Theme configuration
-├── package.json
-└── tsconfig.json
-```
-
-### Local Development
-
-```bash
-# Clone the repository
-git clone <repo-url>
-cd pizza
-
-# Install dependencies
-pnpm install
-
-# Development mode
-pnpm dev
-
-# Build
-pnpm build
-
-# Run
-pnpm start
-```
-
----
-
-## Dependencies
-
-- [pi-coding-agent](https://github.com/badlogic/pi-coding-agent) — Agent session management and extension system
-- [pi-ai](https://github.com/badlogic/pi-coding-agent) — AI model interface
-- [pi-tui](https://github.com/badlogic/pi-coding-agent) — Terminal user interface
-
----
-
-## Configuration
-
-Pizza uses the `.pizza` directory to store configuration and session data. It is created automatically on first run.
-
----
-
-## License
-
-MIT

package/README.zh-CN.md

@@ -0,0 +1,36 @@
+# Pizza
+
+Pizza 是一个事件驱动的 agent。你的每一次对话、工具调用和文件修改，都是不可变日志里的一条事件。UI、LLM 上下文和会话树，都只是这条日志的投影。
+
+
+[English](./README.md)
+
+## 关于它
+
+Pizza 的表壳来源于 Pi -> Pizza, 感谢 Pi 的开源。
+
+- **Reactor 驱动的 turn 循环**
+  区别于 `Pi, Claude Code, Codex`，Pizza 没有用一个脆弱的 `while true` 循环来跑 agent 主循环。每一次 turn 都是一张事件-处理器表驱动的状态机。结果是：中断、重试、并行工具调用、turn 内失败都能被可靠处理。
+
+- **日志是唯一事实来源**
+  每一条消息、每一次模型调用、每一个工具结果、每一次文件变更，都会被写入不可变的 `EventStore`（SQLite）。UI、LLM 上下文、会话树都是这条日志的实时投影。状态不再藏在可变对象里 —— 它可以被重建、审计、回放，因为日志就是唯一的事实来源。
+
+- **只有一个执行工具 - CLI**
+  JSON 在 API 层对程序处理友好但对模型可不是，Pizza 激进的只提供给模型一个工具 - `CLI Tool`, 模型通过其来调用 `read`、`write`、`edit` 和其它命令行命令，出乎意料的是，它表现的更好更稳。
+
+- **为什么要 New Session**
+  在 Pizza 中你不需要手工去新建会话，把它看作你可以持续聊十年的朋友的长程任务，朋友自己会去管理好自己的上下文不是通过压缩。
+
+- **所有界面共享同一个运行时**
+  交互式 TUI、JSON-RPC 服务、单次打印模式都消费同一个 `SessionFacade` 的事件流。你可以脚本化它、嵌入它，或者直接在终端聊天 —— 它是同一个 agent。
+
+- **Git Log 一样的分支树记忆**
+  会话可以从任意一条历史消息分叉。回退、分支、对比。随时随地重开人生。  
+
+## 快速开始
+
+```bash
+npm install -g pizza
+export ZAI_API_KEY=your_zai_api_key
+pizza
+```

package/dist/bun/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bun/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+process.title = "pizza";
+process.emitWarning = (() => { });
+await import("./register-bedrock.js");
+await import("../cli.js");
+export {};

package/dist/bun/register-bedrock.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bun/register-bedrock.js

@@ -0,0 +1,3 @@
+import { setBedrockProviderModule } from "@earendil-works/pi-ai/api/bedrock-converse-stream.lazy";
+import { bedrockProviderModule } from "@earendil-works/pi-ai/bedrock-provider";
+setBedrockProviderModule(bedrockProviderModule);

package/dist/cli/args.d.ts

@@ -0,0 +1,48 @@
+/**
+ * CLI argument parsing and help display
+ */
+import type { ThinkingLevel } from "../core/agent/types.js";
+import type { ExtensionFlag } from "../core/extensions/types.js";
+export type Mode = "text" | "json" | "rpc" | "gui";
+export interface Args {
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    systemPrompt?: string;
+    appendSystemPrompt?: string[];
+    thinking?: ThinkingLevel;
+    rewind?: string | true;
+    help?: boolean;
+    version?: boolean;
+    mode?: Mode;
+    noSession?: boolean;
+    sessionDir?: string;
+    models?: string[];
+    tools?: string[];
+    noTools?: boolean;
+    extensions?: string[];
+    noExtensions?: boolean;
+    print?: boolean;
+    export?: string;
+    noSkills?: boolean;
+    skills?: string[];
+    promptTemplates?: string[];
+    noPromptTemplates?: boolean;
+    themes?: string[];
+    noThemes?: boolean;
+    noContextFiles?: boolean;
+    listModels?: string | true;
+    offline?: boolean;
+    verbose?: boolean;
+    messages: string[];
+    fileArgs: string[];
+    /** Unknown flags (potentially extension flags) - map of flag name to value */
+    unknownFlags: Map<string, boolean | string>;
+    diagnostics: Array<{
+        type: "warning" | "error";
+        message: string;
+    }>;
+}
+export declare function isValidThinkingLevel(level: string): level is ThinkingLevel;
+export declare function parseArgs(args: string[]): Args;
+export declare function printHelp(extensionFlags?: ExtensionFlag[]): void;

package/dist/cli/args.js

@@ -0,0 +1,330 @@
+/**
+ * CLI argument parsing and help display
+ */
+import chalk from "chalk";
+import { APP_NAME, CONFIG_DIR_NAME, ENV_AGENT_DIR } from "../config.js";
+const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export function isValidThinkingLevel(level) {
+    return VALID_THINKING_LEVELS.includes(level);
+}
+export function parseArgs(args) {
+    const result = {
+        messages: [],
+        fileArgs: [],
+        unknownFlags: new Map(),
+        diagnostics: [],
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (i === 0 && arg === "gui") {
+            result.mode = "gui";
+        }
+        else if (arg === "--help" || arg === "-h") {
+            result.help = true;
+        }
+        else if (arg === "--version" || arg === "-v") {
+            result.version = true;
+        }
+        else if (arg === "--mode" && i + 1 < args.length) {
+            const mode = args[++i];
+            if (mode === "text" || mode === "json" || mode === "rpc" || mode === "gui") {
+                result.mode = mode;
+            }
+        }
+        else if (arg === "--rewind") {
+            // --rewind [id]: alone = auto-resume latest, with id = jump to branch
+            if (i + 1 < args.length && !args[i + 1].startsWith("-") && !args[i + 1].startsWith("@")) {
+                result.rewind = args[++i];
+            }
+            else {
+                result.rewind = true;
+            }
+        }
+        else if (arg === "--provider" && i + 1 < args.length) {
+            result.provider = args[++i];
+        }
+        else if (arg === "--model" && i + 1 < args.length) {
+            result.model = args[++i];
+        }
+        else if (arg === "--api-key" && i + 1 < args.length) {
+            result.apiKey = args[++i];
+        }
+        else if (arg === "--system-prompt" && i + 1 < args.length) {
+            result.systemPrompt = args[++i];
+        }
+        else if (arg === "--append-system-prompt" && i + 1 < args.length) {
+            result.appendSystemPrompt = result.appendSystemPrompt ?? [];
+            result.appendSystemPrompt.push(args[++i]);
+        }
+        else if (arg === "--no-session") {
+            result.noSession = true;
+        }
+        else if (arg === "--session-dir" && i + 1 < args.length) {
+            result.sessionDir = args[++i];
+        }
+        else if (arg === "--models" && i + 1 < args.length) {
+            result.models = args[++i].split(",").map((s) => s.trim());
+        }
+        else if (arg === "--no-tools") {
+            result.noTools = true;
+        }
+        else if (arg === "--tools" && i + 1 < args.length) {
+            result.tools = args[++i]
+                .split(",")
+                .map((s) => s.trim())
+                .filter((name) => name.length > 0);
+        }
+        else if (arg === "--thinking" && i + 1 < args.length) {
+            const level = args[++i];
+            if (isValidThinkingLevel(level)) {
+                result.thinking = level;
+            }
+            else {
+                result.diagnostics.push({
+                    type: "warning",
+                    message: `Invalid thinking level "${level}". Valid values: ${VALID_THINKING_LEVELS.join(", ")}`,
+                });
+            }
+        }
+        else if (arg === "--print" || arg === "-p") {
+            result.print = true;
+        }
+        else if (arg === "--export" && i + 1 < args.length) {
+            result.export = args[++i];
+        }
+        else if ((arg === "--extension" || arg === "-e") && i + 1 < args.length) {
+            result.extensions = result.extensions ?? [];
+            result.extensions.push(args[++i]);
+        }
+        else if (arg === "--no-extensions" || arg === "-ne") {
+            result.noExtensions = true;
+        }
+        else if (arg === "--skill" && i + 1 < args.length) {
+            result.skills = result.skills ?? [];
+            result.skills.push(args[++i]);
+        }
+        else if (arg === "--prompt-template" && i + 1 < args.length) {
+            result.promptTemplates = result.promptTemplates ?? [];
+            result.promptTemplates.push(args[++i]);
+        }
+        else if (arg === "--theme" && i + 1 < args.length) {
+            result.themes = result.themes ?? [];
+            result.themes.push(args[++i]);
+        }
+        else if (arg === "--no-skills" || arg === "-ns") {
+            result.noSkills = true;
+        }
+        else if (arg === "--no-prompt-templates" || arg === "-np") {
+            result.noPromptTemplates = true;
+        }
+        else if (arg === "--no-themes") {
+            result.noThemes = true;
+        }
+        else if (arg === "--no-context-files" || arg === "-nc") {
+            result.noContextFiles = true;
+        }
+        else if (arg === "--list-models") {
+            // Check if next arg is a search pattern (not a flag or file arg)
+            if (i + 1 < args.length && !args[i + 1].startsWith("-") && !args[i + 1].startsWith("@")) {
+                result.listModels = args[++i];
+            }
+            else {
+                result.listModels = true;
+            }
+        }
+        else if (arg === "--verbose") {
+            result.verbose = true;
+        }
+        else if (arg === "--offline") {
+            result.offline = true;
+        }
+        else if (arg.startsWith("@")) {
+            result.fileArgs.push(arg.slice(1)); // Remove @ prefix
+        }
+        else if (arg.startsWith("--")) {
+            const eqIndex = arg.indexOf("=");
+            if (eqIndex !== -1) {
+                result.unknownFlags.set(arg.slice(2, eqIndex), arg.slice(eqIndex + 1));
+            }
+            else {
+                const flagName = arg.slice(2);
+                const next = args[i + 1];
+                if (next !== undefined && !next.startsWith("-") && !next.startsWith("@")) {
+                    result.unknownFlags.set(flagName, next);
+                    i++;
+                }
+                else {
+                    result.unknownFlags.set(flagName, true);
+                }
+            }
+        }
+        else if (arg.startsWith("-") && !arg.startsWith("--")) {
+            result.diagnostics.push({ type: "error", message: `Unknown option: ${arg}` });
+        }
+        else if (!arg.startsWith("-")) {
+            result.messages.push(arg);
+        }
+    }
+    return result;
+}
+export function printHelp(extensionFlags) {
+    const extensionFlagsText = extensionFlags && extensionFlags.length > 0
+        ? `\n${chalk.bold("Extension CLI Flags:")}\n${extensionFlags
+            .map((flag) => {
+            const value = flag.type === "string" ? " <value>" : "";
+            const description = flag.description ?? `Registered by ${flag.extensionPath}`;
+            return `  --${flag.name}${value}`.padEnd(30) + description;
+        })
+            .join("\n")}\n`
+        : "";
+    console.log(`${chalk.bold(APP_NAME)} - AI coding assistant with cli tool and built-in commands
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} [options] [@files...] [messages...]
+
+${chalk.bold("Built-in Commands (handled internally by the cli tool):")}
+  builtin read <path> [--offset N] [--limit N]  # Read file with 2-hex line anchors
+  builtin write <path> <content>               # Write file
+  builtin edit <path> <op> <range> [new]      # Edit anchored whole line(s)
+
+All other commands (grep, find, ls, git, npm, etc.) are passed to the system shell as-is.
+If grep/find/ls are missing from PATH, Pizza injects temporary shims only for those missing commands.
+
+${chalk.bold("Commands:")}
+  ${APP_NAME} gui                      Open the local GUI workbench
+  ${APP_NAME} install <source> [-l]     Install extension source and add to settings
+  ${APP_NAME} remove <source> [-l]      Remove extension source from settings
+  ${APP_NAME} uninstall <source> [-l]   Alias for remove
+  ${APP_NAME} update [source]           Update installed extensions (skips pinned sources)
+  ${APP_NAME} list                      List installed extensions from settings
+  ${APP_NAME} config                    Open TUI to enable/disable package resources
+  ${APP_NAME} <command> --help          Show help for install/remove/uninstall/update/list
+
+${chalk.bold("Options:")}
+  --provider <name>              Provider name (default: google)
+  --model <pattern>              Model pattern or ID (supports "provider/id" and optional ":<thinking>")
+  --api-key <key>                API key (defaults to env vars)
+  --system-prompt <text>         System prompt (default: coding assistant prompt)
+  --append-system-prompt <text>  Append text or file contents to the system prompt (can be used multiple times)
+  --mode <mode>                  Output mode: text (default), json, rpc, or gui
+  --print, -p                    Non-interactive mode: process prompt and exit
+  --rewind [id]                  Resume eternal conversation (default), or jump to a branch by id
+  --session-dir <dir>            Directory for session storage and lookup
+  --no-session                   Don't save session (ephemeral)
+  --models <patterns>            Comma-separated model patterns for Ctrl+P cycling
+                                 Supports globs (anthropic/*, *sonnet*) and fuzzy matching
+  --no-tools                     Disable all tools by default (built-in and extension)
+  --tools <tools>                Comma-separated allowlist of tool names to enable
+                                 Applies to built-in and extension tools
+  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
+  --extension, -e <path>         Load an extension file (can be used multiple times)
+  --no-extensions, -ne           Disable extension discovery (explicit -e paths still work)
+  --skill <path>                 Load a skill file or directory (can be used multiple times)
+  --no-skills, -ns               Disable skills discovery and loading
+  --prompt-template <path>       Load a prompt template file or directory (can be used multiple times)
+  --no-prompt-templates, -np     Disable prompt template discovery and loading
+  --theme <path>                 Load a theme file or directory (can be used multiple times)
+  --no-themes                    Disable theme discovery and loading
+  --no-context-files, -nc        Disable AGENTS.md and CLAUDE.md discovery and loading
+  --export <file>                Export session file to HTML and exit
+  --list-models [search]         List available models (with optional fuzzy search)
+  --verbose                      Force verbose startup (overrides quietStartup setting)
+  --offline                      Disable startup network operations (same as PIZZA_OFFLINE=1)
+  --help, -h                     Show this help
+  --version, -v                  Show version number
+
+Extensions can register additional flags (e.g., --plan from plan-mode extension).${extensionFlagsText}
+
+${chalk.bold("Examples:")}
+  # Interactive mode
+  ${APP_NAME}
+
+  # Local GUI
+  ${APP_NAME} gui
+
+  # Interactive mode with initial prompt
+  ${APP_NAME} "List all .ts files in src/"
+
+  # Include files in initial message
+  ${APP_NAME} @prompt.md @image.png "What color is the sky?"
+
+  # Non-interactive mode (process and exit)
+  ${APP_NAME} -p "List all .ts files in src/"
+
+  # Multiple messages (interactive)
+  ${APP_NAME} "Read package.json" "What dependencies do we have?"
+
+  # Continue previous session
+  ${APP_NAME} --continue "What did we discuss?"
+
+  # Use different model
+  ${APP_NAME} --provider openai --model gpt-4o-mini "Help me refactor this code"
+
+  # Use model with provider prefix (no --provider needed)
+  ${APP_NAME} --model openai/gpt-4o "Help me refactor this code"
+
+  # Use model with thinking level shorthand
+  ${APP_NAME} --model sonnet:high "Solve this complex problem"
+
+  # Limit model cycling to specific models
+  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o
+
+  # Limit to a specific provider with glob pattern
+  ${APP_NAME} --models "github-copilot/*"
+
+  # Cycle models with fixed thinking levels
+  ${APP_NAME} --models sonnet:high,haiku:low
+
+  # Start with a specific thinking level
+  ${APP_NAME} --thinking high "Solve this complex problem"
+
+  # Read-only mode (no file modifications possible)
+  ${APP_NAME} --tools read,grep,find,ls -p "Review the code in src/"
+
+  # Export an event session to HTML
+  ${APP_NAME} --export event-session:<workspace-id>:<session-id>
+  ${APP_NAME} --export <session-id> output.html
+
+${chalk.bold("Environment Variables:")}
+  ANTHROPIC_API_KEY                - Anthropic Claude API key
+  ANTHROPIC_OAUTH_TOKEN            - Anthropic OAuth token (alternative to API key)
+  OPENAI_API_KEY                   - OpenAI GPT API key
+  AZURE_OPENAI_API_KEY             - Azure OpenAI API key
+  AZURE_OPENAI_BASE_URL            - Azure OpenAI base URL (https://{resource}.openai.azure.com/openai/v1)
+  AZURE_OPENAI_RESOURCE_NAME       - Azure OpenAI resource name (alternative to base URL)
+  AZURE_OPENAI_API_VERSION         - Azure OpenAI API version (default: v1)
+  AZURE_OPENAI_DEPLOYMENT_NAME_MAP - Azure OpenAI model=deployment map (comma-separated)
+  GEMINI_API_KEY                   - Google Gemini API key
+  GROQ_API_KEY                     - Groq API key
+  CEREBRAS_API_KEY                 - Cerebras API key
+  XAI_API_KEY                      - xAI Grok API key
+  FIREWORKS_API_KEY                - Fireworks API key
+  OPENROUTER_API_KEY               - OpenRouter API key
+  AI_GATEWAY_API_KEY               - Vercel AI Gateway API key
+  ZAI_API_KEY                      - ZAI API key
+  MISTRAL_API_KEY                  - Mistral API key
+  MINIMAX_API_KEY                  - MiniMax API key
+  OPENCODE_API_KEY                 - OpenCode Zen/OpenCode Go API key
+  KIMI_API_KEY                     - Kimi For Coding API key
+  AWS_PROFILE                      - AWS profile for Amazon Bedrock
+  AWS_ACCESS_KEY_ID                - AWS access key for Amazon Bedrock
+  AWS_SECRET_ACCESS_KEY            - AWS secret key for Amazon Bedrock
+  AWS_BEARER_TOKEN_BEDROCK         - Bedrock API key (bearer token)
+  AWS_REGION                       - AWS region for Amazon Bedrock (e.g., us-east-1)
+  ${ENV_AGENT_DIR.padEnd(32)} - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
+  PIZZA_PACKAGE_DIR                - Override package directory (for Nix/Guix store paths)
+  PIZZA_OFFLINE                    - Disable startup network operations when set to 1/true/yes
+  PIZZA_TELEMETRY                  - Override install telemetry when set to 1/true/yes or 0/false/no
+  PIZZA_SHARE_VIEWER_URL           - Base URL for /share command (default: https://pizza.dev/session/)
+  PIZZA_AI_ANTIGRAVITY_VERSION     - Override Antigravity User-Agent version (e.g., 1.23.0)
+
+${chalk.bold("Built-in Tool Names:")}
+  read   - Read file contents
+  cli    - Execute CLI commands
+  edit   - Edit files with find/replace
+  write  - Write files (creates/overwrites)
+  grep   - Search file contents (read-only, off by default)
+  find   - Find files by glob pattern (read-only, off by default)
+  ls     - List directory contents (read-only, off by default)
+`);
+}

package/dist/cli/config-selector.d.ts

@@ -0,0 +1,13 @@
+/**
+ * TUI config selector for `pizza config` command
+ */
+import type { ResolvedPaths } from "../core/package-manager.js";
+import type { SettingsManager } from "../core/settings-manager.js";
+export interface ConfigSelectorOptions {
+    resolvedPaths: ResolvedPaths;
+    settingsManager: SettingsManager;
+    cwd: string;
+    agentDir: string;
+}
+/** Show TUI config selector and return when closed */
+export declare function selectConfig(options: ConfigSelectorOptions): Promise<void>;

package/dist/cli/config-selector.js

@@ -0,0 +1,30 @@
+/**
+ * TUI config selector for `pizza config` command
+ */
+import { ProcessTerminal, TUI } from "@earendil-works/pi-tui";
+import { ConfigSelectorComponent } from "../modes/interactive/components/config-selector.js";
+import { initTheme, stopThemeWatcher } from "../modes/interactive/theme/theme.js";
+/** Show TUI config selector and return when closed */
+export async function selectConfig(options) {
+    // Initialize theme before showing TUI
+    initTheme(options.settingsManager.getTheme(), true);
+    return new Promise((resolve) => {
+        const ui = new TUI(new ProcessTerminal());
+        let resolved = false;
+        const selector = new ConfigSelectorComponent(options.resolvedPaths, options.settingsManager, options.cwd, options.agentDir, () => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                stopThemeWatcher();
+                resolve();
+            }
+        }, () => {
+            ui.stop();
+            stopThemeWatcher();
+            process.exit(0);
+        }, () => ui.requestRender());
+        ui.addChild(selector);
+        ui.setFocus(selector.getResourceList());
+        ui.start();
+    });
+}

package/dist/cli/file-processor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+import type { ImageContent } from "@earendil-works/pi-ai/compat";
+export interface ProcessedFiles {
+    text: string;
+    images: ImageContent[];
+}
+export interface ProcessFileOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+}
+/** Process @file arguments into text content and image attachments */
+export declare function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles>;