shortcutxl 0.2.0

package/agent-docs/examples/sdk/README.md

@@ -0,0 +1,144 @@
+# SDK Examples
+
+Programmatic usage of shortcutxl via `createAgentSession()`.
+
+## Examples
+
+| File | Description |
+|------|-------------|
+| `01-minimal.ts` | Simplest usage with all defaults |
+| `02-custom-model.ts` | Select model and thinking level |
+| `03-custom-prompt.ts` | Replace or modify system prompt |
+| `04-skills.ts` | Discover, filter, or replace skills |
+| `05-tools.ts` | Built-in tools, custom tools |
+| `06-extensions.ts` | Logging, blocking, result modification |
+| `07-context-files.ts` | AGENTS.md context files |
+| `08-slash-commands.ts` | File-based slash commands |
+| `09-api-keys-and-oauth.ts` | API key resolution, OAuth config |
+| `10-settings.ts` | Override compaction, retry, terminal settings |
+| `11-sessions.ts` | In-memory, persistent, continue, list sessions |
+| `12-full-control.ts` | Replace everything, no discovery |
+
+## Running
+
+```bash
+cd packages/coding-agent
+npx tsx examples/sdk/01-minimal.ts
+```
+
+## Quick Reference
+
+```typescript
+import { getModel } from "shortcutxl";
+import {
+  AuthStorage,
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager,
+  codingTools,
+  readOnlyTools,
+  readTool, bashTool, editTool, writeTool,
+} from "shortcutxl";
+
+// Auth and models setup
+const authStorage = AuthStorage.create();
+const modelRegistry = new ModelRegistry(authStorage);
+
+// Minimal
+const { session } = await createAgentSession({ authStorage, modelRegistry });
+
+// Custom model
+const model = getModel("anthropic", "claude-opus-4-5");
+const { session } = await createAgentSession({ model, thinkingLevel: "high", authStorage, modelRegistry });
+
+// Modify prompt
+const loader = new DefaultResourceLoader({
+  systemPromptOverride: (base) => `${base}\n\nBe concise.`,
+});
+await loader.reload();
+const { session } = await createAgentSession({ resourceLoader: loader, authStorage, modelRegistry });
+
+// Read-only
+const { session } = await createAgentSession({ tools: readOnlyTools, authStorage, modelRegistry });
+
+// In-memory
+const { session } = await createAgentSession({
+  sessionManager: SessionManager.inMemory(),
+  authStorage,
+  modelRegistry,
+});
+
+// Full control
+const customAuth = AuthStorage.create("/my/app/auth.json");
+customAuth.setRuntimeApiKey("anthropic", process.env.MY_KEY!);
+const customRegistry = new ModelRegistry(customAuth);
+
+const resourceLoader = new DefaultResourceLoader({
+  systemPromptOverride: () => "You are helpful.",
+  extensionFactories: [myExtension],
+  skillsOverride: () => ({ skills: [], diagnostics: [] }),
+  agentsFilesOverride: () => ({ agentsFiles: [] }),
+  promptsOverride: () => ({ prompts: [], diagnostics: [] }),
+});
+await resourceLoader.reload();
+
+const { session } = await createAgentSession({
+  model,
+  authStorage: customAuth,
+  modelRegistry: customRegistry,
+  resourceLoader,
+  tools: [readTool, bashTool],
+  customTools: [{ tool: myTool }],
+  sessionManager: SessionManager.inMemory(),
+  settingsManager: SettingsManager.inMemory(),
+});
+
+// Run prompts
+session.subscribe((event) => {
+  if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+    process.stdout.write(event.assistantMessageEvent.delta);
+  }
+});
+await session.prompt("Hello");
+```
+
+## Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `authStorage` | `AuthStorage.create()` | Credential storage |
+| `modelRegistry` | `new ModelRegistry(authStorage)` | Model registry |
+| `cwd` | `process.cwd()` | Working directory |
+| `agentDir` | `~/.shortcut/agent` | Config directory |
+| `model` | From settings/first available | Model to use |
+| `thinkingLevel` | From settings/"off" | off, low, medium, high |
+| `tools` | `codingTools` | Built-in tools |
+| `customTools` | `[]` | Additional tool definitions |
+| `resourceLoader` | DefaultResourceLoader | Resource loader for extensions, skills, prompts, themes |
+| `sessionManager` | `SessionManager.create(cwd)` | Persistence |
+| `settingsManager` | `SettingsManager.create(cwd, agentDir)` | Settings overrides |
+
+## Events
+
+```typescript
+session.subscribe((event) => {
+  switch (event.type) {
+    case "message_update":
+      if (event.assistantMessageEvent.type === "text_delta") {
+        process.stdout.write(event.assistantMessageEvent.delta);
+      }
+      break;
+    case "tool_execution_start":
+      console.log(`Tool: ${event.toolName}`);
+      break;
+    case "tool_execution_end":
+      console.log(`Result: ${event.result}`);
+      break;
+    case "agent_end":
+      console.log("Done");
+      break;
+  }
+});
+```

package/agent-docs/xll-skill.md

@@ -0,0 +1,61 @@
+# ShortcutXL — Agent Reference
+
+Two channels to control Excel:
+
+1. **`POST /exec`** — run Python with full COM access. Use for imperative actions (write cells, format, create charts, read data).
+2. **Filesystem (`modules/`)** — write `.py` files with `@xl_func` decorators. Hot-reloads in ~200ms. Use for custom Excel formulas and tick loops.
+
+---
+
+## `/exec`
+
+```
+POST http://localhost:8080/exec
+Content-Type: application/json
+{"code": "from shortcut_xl import xl_app\napp = xl_app()\napp.Range('A1').Value = 42"}
+```
+
+Returns `{"ok": true, "output": "..."}` or `{"ok": false, "error": "..."}`.
+
+**Only import `xl_app` in `/exec`.** Never use `xl_batch`, `schedule_call`, or `xl_log` — those cause cross-thread COM errors. You already have direct main-thread access.
+
+`xl_app()` returns `Excel.Application` — same API as VBA. Use `print()` to read values back.
+
+---
+
+## `modules/`
+
+Discover the path: `GET http://localhost:8080/config` → `{"modules_path": "..."}`.
+
+```python
+# modules/example.py
+from shortcut_xl import xl_func, schedule_call, xl_app
+
+@xl_func
+def my_formula(x, y):
+    return x + y          # In Excel: =my_formula(A1, B1)
+
+def tick():
+    xl_app().Calculate()
+    schedule_call(tick, 1)  # continuous updates
+
+schedule_call(tick, 1)
+```
+
+Rules: function name = formula name, args are `float`/`str`/`None`, return `float`/`int`/`str`/`bool`, max 32 functions, all modules reload together on any file change.
+
+---
+
+## Hard rules
+
+| | `/exec` | `modules/` |
+|---|---|---|
+| **Use for** | One-shot actions, layout, formatting | Custom formulas, live data, tick loops |
+| **Imports** | `xl_app` only | `xl_func`, `xl_app`, `xl_batch`, `schedule_call`, `xl_log` |
+
+Never mix the two.
+
+## Debugging
+
+- `/exec` errors → response `error` field
+- `@xl_func` errors → `#VALUE!` in cell, details in `%TEMP%\shortcutxl.log`

package/agent-docs/xll-spec.md

@@ -0,0 +1,110 @@
+# ShortcutXL
+
+A native Excel add-in (`.xll`) written in C that turns Excel into a programmable surface for an AI agent. The agent runs locally on Windows as a TypeScript/Node.js CLI with a terminal TUI. It controls Excel through two channels: writing Python files for custom functions, and sending code blocks over HTTP for direct manipulation.
+
+See `../agent/PLAN.md` for the agent architecture (loop, multiagent, session management).
+
+---
+
+## Architecture
+
+```
+┌─ Windows ──────────────────────────────────────────┐
+│                                                     │
+│  Terminal (PowerShell / Windows Terminal)            │
+│  └─ Agent CLI (Node.js, TypeScript)                 │
+│     ├─ TUI (shortcutxl)                          │
+│     ├─ Supervisor agent loop                        │
+│     │   ├─ POST /exec → localhost:8080 ────────────┼──► HTTP
+│     │   ├─ writes .py → modules/ ──────────────────┼──► filesystem
+│     │   └─ Task tool → spawns worker agents         │
+│     └─ shortcutxl (Anthropic, OpenAI, Google)   │
+│                                                     │
+│  Excel.exe                                          │
+│  └─ ShortcutXL (in-process)                        │
+│     ├─ HTTP server (:8080)                          │
+│     │   ├─ GET /config (paths)                      │
+│     │   └─ POST /exec (run Python)                  │
+│     ├─ fs_watcher (hot-reload)                      │
+│     ├─ CPython 3.12 (embedded)                      │
+│     └─ COM → all open workbooks                     │
+│                                                     │
+└─────────────────────────────────────────────────────┘
+```
+
+On startup the agent calls `GET /config` to discover the `modules/` path and is ready to go. Both agent and Excel run natively on Windows — no WSL boundary, no filesystem translation.
+
+---
+
+## Two Channels
+
+### 1. `POST /exec` — imperative actions
+
+Agent sends a Python code block. The XLL runs it in the embedded runtime with full COM access to Excel. The result (stdout + stderr) is returned.
+
+```
+POST http://localhost:8080/exec
+{"code": "from shortcut_xl import xl_app\napp = xl_app()\napp.Range('A1:D1').Value = [['Name','Revenue','Growth','Status']]\napp.Range('A1:D1').Font.Bold = True"}
+
+→ {"ok": true, "output": ""}
+```
+
+Use this for: writing cells, reading data, formatting, creating charts, any one-shot action.
+
+### 2. Filesystem — custom functions
+
+Agent writes `.py` files with `@xl_func` decorators to `modules/`. The XLL watches the directory, hot-reloads within ~200ms, and registers them as native Excel formulas.
+
+```python
+# modules/dashboard.py
+from shortcut_xl import xl_func
+
+@xl_func
+def revenue_ytd(region):
+    return {"EMEA": 1.2e6, "NA": 3.4e6}.get(region, 0)
+```
+
+In Excel: `=revenue_ytd("EMEA")` → `1200000`
+
+Use this for: custom worksheet functions that Excel's calc engine calls repeatedly, tick loops, animations.
+
+### Why two channels
+
+| Need | Channel | Reason |
+|---|---|---|
+| Write cells, format, charts | `/exec` | One-shot, result discarded after execution |
+| Custom formulas (`=foo()`) | filesystem | Excel calls them on every recalculation |
+| Tick loops, animations | filesystem | Persistent code running on a timer |
+
+HTTP gives the agent a simple request/response interface for one-shot operations. The filesystem channel handles the only thing HTTP can't: registering functions with Excel's calc engine via `xlfRegister`, which requires in-process code that persists between calls.
+
+---
+
+## What Runs Where
+
+| Component | Where | Why |
+|---|---|---|
+| Agent CLI (LLM calls, orchestration, TUI) | Windows, Node.js process | Native filesystem + HTTP to Excel, no cross-OS friction |
+| ShortcutXL (HTTP, fs_watcher, Python, COM) | Windows, inside excel.exe | In-process access to Excel's internals |
+| `modules/*.py` | Windows filesystem | Agent writes directly, XLL watches for changes |
+
+---
+
+## Installation
+
+**Installer (recommended):** MSI drops `ShortcutXL.xll` + embedded Python runtime. Writes registry key:
+
+```
+HKCU\Software\Microsoft\Office\<version>\Excel\Options
+  OPEN = /R "C:\Program Files\Shortcut\ShortcutXL.xll"
+```
+
+Excel loads it automatically on every startup.
+
+**Manual:** Excel → File → Options → Add-ins → Manage: Excel Add-ins → Browse → select `ShortcutXL.xll`.
+
+---
+
+## Platform
+
+Windows only. The XLL API is a Windows DLL interface. The custom spreadsheet engine (see `new-sheet-spec.md`) is the cross-platform path.

package/dist/cli/args.js

@@ -0,0 +1,290 @@
+/**
+ * CLI argument parsing and help display
+ */
+import chalk from 'chalk';
+import { APP_NAME, CONFIG_DIR_NAME, ENV_AGENT_DIR } from '../config.js';
+import { isValidThinkingLevel, VALID_THINKING_LEVELS } from '../core/defaults.js';
+import { allTools } from '../core/tools/index.js';
+export function parseArgs(args, extensionFlags) {
+    const result = {
+        messages: [],
+        fileArgs: [],
+        unknownFlags: new Map()
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        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') {
+                result.mode = mode;
+            }
+        }
+        else if (arg === '--continue' || arg === '-c') {
+            result.continue = true;
+        }
+        else if (arg === '--resume' || arg === '-r') {
+            result.resume = 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 = args[++i];
+        }
+        else if (arg === '--no-session') {
+            result.noSession = true;
+        }
+        else if (arg === '--session' && i + 1 < args.length) {
+            result.session = args[++i];
+        }
+        else if (arg === '--session-dir' && i + 1 < args.length) {
+            result.sessionDir = args[++i];
+        }
+        else if (arg === '--no-tools') {
+            result.noTools = true;
+        }
+        else if (arg === '--no-custom-tools') {
+            result.noCustomTools = true;
+        }
+        else if (arg === '--custom-tools' && i + 1 < args.length) {
+            result.customTools = args[++i].split(',').map((s) => s.trim());
+        }
+        else if (arg === '--tools' && i + 1 < args.length) {
+            const toolNames = args[++i].split(',').map((s) => s.trim());
+            const validTools = [];
+            for (const name of toolNames) {
+                if (name in allTools) {
+                    validTools.push(name);
+                }
+                else {
+                    console.error(chalk.yellow(`Warning: Unknown tool "${name}". Valid tools: ${Object.keys(allTools).join(', ')}`));
+                }
+            }
+            result.tools = validTools;
+        }
+        else if (arg === '--thinking' && i + 1 < args.length) {
+            const level = args[++i];
+            if (isValidThinkingLevel(level)) {
+                result.thinking = level;
+            }
+            else {
+                console.error(chalk.yellow(`Warning: 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 === '--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 === '--subagent') {
+            result.subagent = true;
+        }
+        else if (arg === '--offline') {
+            result.offline = true;
+        }
+        else if (arg.startsWith('@')) {
+            result.fileArgs.push(arg.slice(1)); // Remove @ prefix
+        }
+        else if (arg.startsWith('--') && extensionFlags) {
+            // Check if it's an extension-registered flag
+            const flagName = arg.slice(2);
+            const extFlag = extensionFlags.get(flagName);
+            if (extFlag) {
+                if (extFlag.type === 'boolean') {
+                    result.unknownFlags.set(flagName, true);
+                }
+                else if (extFlag.type === 'string' && i + 1 < args.length) {
+                    result.unknownFlags.set(flagName, args[++i]);
+                }
+            }
+            // Unknown flags without extensionFlags are silently ignored (first pass)
+        }
+        else if (!arg.startsWith('-')) {
+            result.messages.push(arg);
+        }
+    }
+    return result;
+}
+export function printHelp() {
+    console.log(`${chalk.bold(APP_NAME)} - AI coding assistant with read, bash, edit, write tools
+
+${chalk.bold('Usage:')}
+  ${APP_NAME} [options] [@files...] [messages...]
+
+${chalk.bold('Commands:')}
+  ${APP_NAME} install <source> [-l]    Install extension source and add to settings
+  ${APP_NAME} remove <source> [-l]     Remove extension source from settings
+  ${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/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
+  --mode <mode>                  Output mode: text (default), json, or rpc
+  --print, -p                    Non-interactive mode: process prompt and exit
+  --continue, -c                 Continue previous session
+  --resume, -r                   Select a session to resume
+  --session <path>               Use specific session file
+  --session-dir <dir>            Directory for session storage and lookup
+  --no-session                   Don't save session (ephemeral)
+  --no-tools                     Disable all built-in tools
+  --tools <tools>                Comma-separated list of tools to enable (default: read,bash,edit,write)
+                                 Available: read, bash, edit, write, grep, find, ls
+  --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
+  --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 SHORTCUT_OFFLINE=1)
+  --help, -h                     Show this help
+  --version, -v                  Show version number
+
+Extensions can register additional flags (e.g., --plan from plan-mode extension).
+
+${chalk.bold('Examples:')}
+  # Interactive mode
+  ${APP_NAME}
+
+  # 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"
+
+  # 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 a session file to HTML
+  ${APP_NAME} --export ~/${CONFIG_DIR_NAME}/agent/sessions/--path--/session.jsonl
+  ${APP_NAME} --export session.jsonl 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
+  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
+  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)
+  SHORTCUT_PACKAGE_DIR             - Override package directory (for Nix/Guix store paths)
+  SHORTCUT_OFFLINE                 - Disable startup network operations when set to 1/true/yes
+  SHORTCUT_SHARE_VIEWER_URL        - Base URL for /share command
+  SHORTCUT_SKIP_VERSION_CHECK      - Skip version check at startup
+
+${chalk.bold('Available Tools (default: read, bash, edit, write):')}
+  read   - Read file contents
+  bash   - Execute bash 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)
+`);
+}
+//# sourceMappingURL=args.js.map

package/dist/cli/config-selector.js

@@ -0,0 +1,31 @@
+/**
+ * TUI config selector for `pi config` command
+ */
+import { ProcessTerminal, TUI } from '../tui/index.js';
+import { initTheme, stopThemeWatcher } from '../core/theme.js';
+import { ConfigSelectorComponent } from '../modes/interactive/components/config-selector.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();
+    });
+}
+//# sourceMappingURL=config-selector.js.map