voracode 0.0.1

package/dist/main.js

@@ -0,0 +1,2842 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { Command as Command16 } from "commander";
+
+// src/cli/run.ts
+import { Command } from "commander";
+
+// src/storage/database.ts
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var VoraDatabase = class {
+  db;
+  dataDir;
+  constructor() {
+    this.dataDir = join(homedir(), ".local", "share", "voracode");
+    if (!existsSync(this.dataDir)) {
+      mkdirSync(this.dataDir, { recursive: true });
+    }
+    this.db = new Database(join(this.dataDir, "voracode.db"));
+    this.db.exec("PRAGMA journal_mode=WAL");
+    this.db.exec("PRAGMA foreign_keys=ON");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        title TEXT,
+        project_path TEXT,
+        model_provider TEXT NOT NULL,
+        model_name TEXT NOT NULL,
+        total_tokens INTEGER DEFAULT 0,
+        total_turns INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'active',
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        tokens INTEGER,
+        tool_calls TEXT,
+        parent_id INTEGER REFERENCES messages(id),
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memory (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        key TEXT UNIQUE,
+        content TEXT NOT NULL,
+        category TEXT,
+        priority INTEGER DEFAULT 1,
+        tags TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+        content, tags,
+        content=memory,
+        content_rowid=id
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS skills (
+        name TEXT PRIMARY KEY,
+        description TEXT NOT NULL,
+        source TEXT NOT NULL,
+        path TEXT NOT NULL,
+        trigger_count INTEGER DEFAULT 0,
+        success_count INTEGER DEFAULT 0,
+        last_used_at TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS stats (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        date TEXT NOT NULL UNIQUE,
+        api_calls INTEGER DEFAULT 0,
+        tokens_in INTEGER DEFAULT 0,
+        tokens_out INTEGER DEFAULT 0,
+        cache_hits INTEGER DEFAULT 0,
+        errors INTEGER DEFAULT 0,
+        tasks_completed INTEGER DEFAULT 0
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS audit_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp TEXT DEFAULT (datetime('now')),
+        event_type TEXT NOT NULL,
+        details TEXT,
+        allowed INTEGER NOT NULL DEFAULT 1
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS checkpoints (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+        message_id INTEGER NOT NULL REFERENCES messages(id),
+        description TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+  }
+  // ── Session operations ──
+  createSession(provider, model, title = "Untitled") {
+    const id = crypto.randomUUID();
+    this.db.run(
+      "INSERT INTO sessions (id, title, model_provider, model_name) VALUES (?, ?, ?, ?)",
+      [id, title, provider, model]
+    );
+    return id;
+  }
+  getSession(id) {
+    return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+  }
+  listSessions(limit = 10) {
+    return this.db.query("SELECT * FROM sessions ORDER BY created_at DESC LIMIT ?").all(limit);
+  }
+  updateSession(id, updates) {
+    const keys = Object.keys(updates);
+    const setClause = keys.map((k) => `${k} = ?`).join(", ");
+    const values = keys.map((k) => updates[k]);
+    values.push(id);
+    this.db.run(`UPDATE sessions SET ${setClause}, updated_at = datetime('now') WHERE id = ?`, values);
+  }
+  deleteSession(id) {
+    this.db.prepare("DELETE FROM sessions WHERE id = ?").run([id]);
+  }
+  // ── Message operations ──
+  addMessage(sessionId, role, content, tokens = 0, toolCalls) {
+    const result = this.db.run(
+      "INSERT INTO messages (session_id, role, content, tokens, tool_calls) VALUES (?, ?, ?, ?, ?)",
+      [sessionId, role, content, tokens, toolCalls || null]
+    );
+    return Number(result.lastInsertRowid);
+  }
+  getMessages(sessionId, limit = 100) {
+    return this.db.query("SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC LIMIT ?").all(sessionId, limit);
+  }
+  // ── Memory operations ──
+  addMemory(key, content, category = "general", tags) {
+    this.db.run(
+      "INSERT OR REPLACE INTO memory (key, content, category, tags, updated_at) VALUES (?, ?, ?, ?, datetime('now'))",
+      [key, content, category, tags || null]
+    );
+  }
+  searchMemory(query) {
+    return this.db.query("SELECT m.* FROM memory_fts f JOIN memory m ON f.rowid = m.id WHERE memory_fts MATCH ? ORDER BY rank LIMIT 10").all(query);
+  }
+  // ── Stats operations ──
+  recordApiCall(tokensIn, tokensOut) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    this.db.run(`
+      INSERT INTO stats (date, api_calls, tokens_in, tokens_out) VALUES (?, 1, ?, ?)
+      ON CONFLICT(date) DO UPDATE SET api_calls = api_calls + 1, tokens_in = tokens_in + ?, tokens_out = tokens_out + ?
+    `, [today, tokensIn, tokensOut, tokensIn, tokensOut]);
+  }
+  getStats(days = 7) {
+    return this.db.query("SELECT * FROM stats WHERE date >= date('now', ? || ' days') ORDER BY date").all(`-${days}`);
+  }
+  // ── Audit operations ──
+  logAudit(eventType, details, allowed = true) {
+    this.db.run(
+      "INSERT INTO audit_log (event_type, details, allowed) VALUES (?, ?, ?)",
+      [eventType, details, allowed ? 1 : 0]
+    );
+  }
+  getAuditLog(limit = 50) {
+    return this.db.query("SELECT * FROM audit_log ORDER BY timestamp DESC LIMIT ?").all(limit);
+  }
+  // ── Checkpoint operations ──
+  createCheckpoint(sessionId, messageId, description) {
+    this.db.run(
+      "INSERT INTO checkpoints (session_id, message_id, description) VALUES (?, ?, ?)",
+      [sessionId, messageId, description]
+    );
+  }
+  // ── Utility ──
+  close() {
+    this.db.close();
+  }
+  getDbPath() {
+    return join(this.dataDir, "voracode.db");
+  }
+  // ── Generic database access (used by SelfImprovementEngine) ──
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  query(sql) {
+    return this.db.prepare(sql);
+  }
+  run(sql, params = []) {
+    this.db.run(sql, params);
+  }
+};
+
+// src/models/router.ts
+var PROVIDER_BASE_URLS = {
+  openai: "https://api.openai.com/v1",
+  deepseek: "https://api.deepseek.com/v1",
+  groq: "https://api.groq.com/openai/v1",
+  together: "https://api.together.xyz/v1",
+  openrouter: "https://openrouter.ai/api/v1",
+  ollama: "http://localhost:11434/v1",
+  huggingface: "https://router.huggingface.co/v1",
+  fireworks: "https://api.fireworks.ai/inference/v1",
+  cerebras: "https://api.cerebras.ai/v1",
+  anthropic: "https://api.anthropic.com/v1",
+  google: "https://generativelanguage.googleapis.com/v1beta"
+};
+var PROVIDER_KEY_PATTERNS = {
+  openai: /^(sk-|sx-)/,
+  anthropic: /^sk-ant-/,
+  deepseek: /^sk-/,
+  groq: /^gsk_/
+};
+var RateLimiter = class {
+  calls = /* @__PURE__ */ new Map();
+  windowMs = 6e4;
+  // 1 minute
+  maxCalls = 10;
+  // 10 calls per minute
+  canCall(provider) {
+    const now = Date.now();
+    const timestamps = this.calls.get(provider) || [];
+    const recent = timestamps.filter((t) => now - t < this.windowMs);
+    this.calls.set(provider, recent);
+    if (recent.length >= this.maxCalls) {
+      return false;
+    }
+    recent.push(now);
+    this.calls.set(provider, recent);
+    return true;
+  }
+  retryAfter(provider) {
+    const timestamps = this.calls.get(provider) || [];
+    if (timestamps.length === 0) return 0;
+    const oldest = timestamps[0];
+    return Math.max(0, Math.ceil((this.windowMs - (Date.now() - oldest)) / 1e3));
+  }
+};
+var ModelRouter = class {
+  keychain = /* @__PURE__ */ new Map();
+  rateLimiter = new RateLimiter();
+  constructor() {
+    this.loadFromEnv();
+  }
+  loadFromEnv() {
+    const envMap = {
+      openai: process.env.OPENAI_API_KEY || process.env.OPENAI_KEY,
+      anthropic: process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_KEY,
+      deepseek: process.env.DEEPSEEK_API_KEY || process.env.DEEPSEEK_KEY,
+      groq: process.env.GROQ_API_KEY || process.env.GROQ_KEY,
+      google: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY,
+      openrouter: process.env.OPENROUTER_API_KEY,
+      huggingface: process.env.HF_API_KEY || process.env.HUGGINGFACE_KEY,
+      together: process.env.TOGETHER_API_KEY,
+      ollama: ""
+      // No key needed for local
+    };
+    for (const [provider, key] of Object.entries(envMap)) {
+      if (key) {
+        this.keychain.set(provider, key);
+      }
+    }
+  }
+  /**
+   * Get the active API key for a provider
+   */
+  getKey(provider) {
+    return this.keychain.get(provider);
+  }
+  /**
+   * Set an API key for a provider
+   */
+  setKey(provider, key) {
+    this.keychain.set(provider, key);
+  }
+  /**
+   * Check if a provider has a valid-looking API key configured
+   */
+  hasValidKey(provider) {
+    const key = this.keychain.get(provider);
+    if (!key) return false;
+    const pattern = PROVIDER_KEY_PATTERNS[provider];
+    if (pattern) return pattern.test(key);
+    return key.length > 8;
+  }
+  /**
+   * Detect provider from model name
+   */
+  detectProvider(modelName) {
+    const normalized = modelName.toLowerCase();
+    if (normalized.startsWith("gpt-") || normalized.startsWith("o3") || normalized.startsWith("o1")) return "openai";
+    if (normalized.startsWith("claude-") || normalized.startsWith("opus") || normalized.startsWith("sonnet") || normalized.startsWith("haiku")) return "anthropic";
+    if (normalized.startsWith("gemini-")) return "google";
+    if (normalized.startsWith("deepseek-")) return "deepseek";
+    if (normalized.startsWith("llama-") || normalized.startsWith("mixtral") || normalized.startsWith("qwen-")) return "groq";
+    if (normalized.startsWith("command-")) return "cohere";
+    return "openai";
+  }
+  /**
+   * Get available models for a provider
+   */
+  getModels(provider) {
+    const modelMap = {
+      openai: ["gpt-4o", "gpt-4o-mini", "o3-mini", "o1"],
+      anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-haiku-4"],
+      deepseek: ["deepseek-chat", "deepseek-v4-flash", "deepseek-v4-pro"],
+      groq: ["llama-3.1-8b", "llama-3.1-70b", "qwen-32b", "mixtral-8x7b"],
+      google: ["gemini-2.5-pro", "gemini-2.5-flash"],
+      ollama: ["llama3.2", "mistral", "deepseek-coder-v2", "qwen2.5-coder"],
+      openrouter: ["openrouter/auto"],
+      huggingface: ["HuggingFaceH4/zephyr-7b-beta"]
+    };
+    return modelMap[provider] || [];
+  }
+  /**
+   * Get provider base URL
+   */
+  getBaseUrl(provider) {
+    return PROVIDER_BASE_URLS[provider] || "";
+  }
+  /**
+   * Chat completion using OpenAI-compatible API
+   * Covers: DeepSeek, Groq, Together, Ollama, OpenRouter, HuggingFace
+   */
+  async chatOpenAI(provider, messages, options) {
+    const baseUrl = this.getBaseUrl(provider);
+    const apiKey = this.keychain.get(provider);
+    if (!apiKey && provider !== "ollama") {
+      throw new Error(`No API key configured for ${provider}. Run: voracode key set ${provider}`);
+    }
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: apiKey ? `Bearer ${apiKey}` : ""
+      },
+      body: JSON.stringify({
+        model: options.model,
+        messages: messages.map((m) => ({
+          role: m.role,
+          content: m.content,
+          ...m.name ? { name: m.name } : {},
+          ...m.tool_calls ? { tool_calls: m.tool_calls } : {},
+          ...m.tool_call_id ? { tool_call_id: m.tool_call_id } : {}
+        })),
+        max_tokens: options.maxTokens || 4096,
+        temperature: options.temperature ?? 0.7,
+        stream: false,
+        ...options.tools && options.tools.length > 0 ? { tools: options.tools, tool_choice: options.toolChoice || "auto" } : {}
+      }),
+      signal: AbortSignal.timeout(6e4)
+      // 60s timeout
+    });
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(`${provider} API error (${response.status}): ${errorBody}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.choices[0]?.message?.content || "",
+      model: data.model,
+      provider,
+      usage: {
+        inputTokens: data.usage?.prompt_tokens || 0,
+        outputTokens: data.usage?.completion_tokens || 0,
+        totalTokens: data.usage?.total_tokens || 0
+      },
+      toolCalls: data.choices[0]?.message?.tool_calls
+    };
+  }
+  /**
+   * Chat completion using Anthropic Messages API
+   */
+  async chatAnthropic(messages, options) {
+    const apiKey = this.keychain.get("anthropic");
+    if (!apiKey) throw new Error("No API key configured for Anthropic. Run: voracode key set anthropic");
+    const systemMsg = messages.find((m) => m.role === "system");
+    const nonSystem = messages.filter((m) => m.role !== "system");
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: options.model,
+        messages: nonSystem.map((m) => ({
+          role: m.role === "assistant" ? "assistant" : "user",
+          content: m.content
+        })),
+        system: systemMsg?.content,
+        max_tokens: options.maxTokens || 4096,
+        temperature: options.temperature ?? 0.7
+      }),
+      signal: AbortSignal.timeout(6e4)
+      // 60s timeout
+    });
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(`Anthropic API error (${response.status}): ${errorBody}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.content?.[0]?.text || "",
+      model: data.model,
+      provider: "anthropic",
+      usage: {
+        inputTokens: data.usage?.input_tokens || 0,
+        outputTokens: data.usage?.output_tokens || 0,
+        totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0)
+      }
+    };
+  }
+  /**
+   * Main chat method — auto-selects correct adapter based on model name
+   */
+  async chat(modelRef, messages, options = {}) {
+    const provider = modelRef.includes("/") ? modelRef.split("/")[0] : this.detectProvider(modelRef);
+    const modelName = modelRef.includes("/") ? modelRef.slice(modelRef.indexOf("/") + 1) : modelRef;
+    if (!this.rateLimiter.canCall(provider)) {
+      const retryAfter = this.rateLimiter.retryAfter(provider);
+      throw new Error(`Rate limited on ${provider}. Retry in ${retryAfter}s. Use voracode pro for higher limits.`);
+    }
+    const fullOptions = { ...options, model: modelName };
+    try {
+      switch (provider) {
+        case "anthropic":
+          return await this.chatAnthropic(messages, fullOptions);
+        case "google":
+          return await this.chatGoogle(messages, fullOptions);
+        default:
+          return await this.chatOpenAI(provider, messages, fullOptions);
+      }
+    } catch (error) {
+      const fallbacks = ["deepseek", "groq", "openrouter"];
+      for (const fb of fallbacks) {
+        if (fb === provider) continue;
+        const fbKey = this.keychain.get(fb);
+        if (fbKey) {
+          try {
+            return await this.chatOpenAI(fb, messages, { ...fullOptions, model: this.getModels(fb)[0] || fb });
+          } catch {
+            continue;
+          }
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Chat completion using Google AI API
+   */
+  async chatGoogle(messages, _options) {
+    const apiKey = this.keychain.get("google");
+    if (!apiKey) throw new Error("No API key configured for Google. Run: voracode key set google");
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${_options.model}:generateContent`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey
+          // Use header instead of URL query param
+        },
+        body: JSON.stringify({
+          contents: messages.filter((m) => m.role !== "system").map((m) => ({
+            role: m.role === "assistant" ? "model" : "user",
+            parts: [{ text: m.content }]
+          })),
+          systemInstruction: messages.find((m) => m.role === "system")?.content ? { parts: [{ text: messages.find((m) => m.role === "system").content }] } : void 0,
+          generationConfig: {
+            maxOutputTokens: _options.maxTokens || 4096,
+            temperature: _options.temperature ?? 0.7
+          }
+        })
+      }
+    );
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(`Google API error (${response.status}): ${errorBody}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.candidates?.[0]?.content?.parts?.[0]?.text || "",
+      model: _options.model,
+      provider: "google",
+      usage: {
+        inputTokens: data.usageMetadata?.promptTokenCount || 0,
+        outputTokens: data.usageMetadata?.candidatesTokenCount || 0,
+        totalTokens: data.usageMetadata?.totalTokenCount || 0
+      }
+    };
+  }
+};
+
+// src/tools/executor.ts
+import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
+import { execSync } from "child_process";
+import { resolve } from "path";
+var BLOCKED_COMMANDS = [
+  "rm -rf /",
+  "rm -rf /*",
+  "sudo ",
+  "mkfs",
+  "dd if=",
+  ":(){",
+  "chmod 777 /",
+  "> /dev/",
+  "format C:",
+  "del /f /s",
+  "rd /s /q",
+  "shutdown",
+  "reboot",
+  "curl ",
+  "wget ",
+  // data exfiltration via download
+  "nc ",
+  "ncat ",
+  "netcat ",
+  // network connections
+  "bash -c",
+  "sh -c",
+  "powershell -c",
+  // encoded cmd execution
+  "chmod +x",
+  // making files executable
+  ">/dev/sda",
+  ">/dev/sdb",
+  // writing to raw disk
+  "| bash",
+  "| sh",
+  "| zsh",
+  // pipe to shell
+  "`",
+  "$("
+  // command substitution
+];
+var PROJECT_ROOT = resolve(process.cwd());
+var ToolExecutor = class {
+  db;
+  tools;
+  constructor(db) {
+    this.db = db;
+    this.tools = /* @__PURE__ */ new Map();
+    this.registerBuiltins();
+  }
+  registerBuiltins() {
+    this.tools.set("file_read", {
+      name: "file_read",
+      description: "Read the contents of a file",
+      execute: (args) => this.fileRead(args.path)
+    });
+    this.tools.set("file_write", {
+      name: "file_write",
+      description: "Write content to a file",
+      execute: (args) => this.fileWrite(args.path, args.content)
+    });
+    this.tools.set("file_edit", {
+      name: "file_edit",
+      description: "Edit a file by replacing text",
+      execute: (args) => this.fileEdit(args.path, args.old_string, args.new_string)
+    });
+    this.tools.set("bash", {
+      name: "bash",
+      description: "Execute a shell command (sandboxed)",
+      execute: (args) => this.execBash(args.command)
+    });
+    this.tools.set("git_status", {
+      name: "git_status",
+      description: "Show git status",
+      execute: () => this.execGit(["status"])
+    });
+    this.tools.set("git_diff", {
+      name: "git_diff",
+      description: "Show git diff",
+      execute: () => this.execGit(["diff"])
+    });
+    this.tools.set("git_commit", {
+      name: "git_commit",
+      description: "Commit changes with a message",
+      execute: (args) => this.execGit(["commit", "-m", args.message])
+    });
+    this.tools.set("code_search", {
+      name: "code_search",
+      description: "Search codebase for a pattern",
+      execute: (args) => this.searchCode(args.pattern, args.path)
+    });
+    this.tools.set("web_fetch", {
+      name: "web_fetch",
+      description: "Fetch content from a URL",
+      execute: (args) => this.webFetch(args.url)
+    });
+    this.tools.set("think", {
+      name: "think",
+      description: "Reason through a problem step by step",
+      execute: (args) => `Reasoning: ${args.reasoning || "No reasoning provided."}`
+    });
+    this.tools.set("list_files", {
+      name: "list_files",
+      description: "List files in a directory",
+      execute: (args) => this.listDir(args.path)
+    });
+  }
+  /**
+   * Execute a tool by name with given arguments
+   */
+  async execute(toolName, argsJson) {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      return `Error: Unknown tool '${toolName}'. Available: ${Array.from(this.tools.keys()).join(", ")}`;
+    }
+    let args = {};
+    try {
+      args = JSON.parse(argsJson);
+    } catch {
+      return `Error: Invalid JSON arguments for tool '${toolName}'`;
+    }
+    this.db.logAudit("tool_execute", JSON.stringify({ tool: toolName, args }));
+    try {
+      const result = await Promise.resolve(tool.execute(args));
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.db.logAudit("tool_error", `${toolName}: ${errorMsg}`, false);
+      return `Error executing ${toolName}: ${errorMsg}`;
+    }
+  }
+  /**
+   * List all registered tools
+   */
+  listTools() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Register a custom tool (for plugins)
+   */
+  registerTool(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Get tool definitions in OpenAI function-calling format
+   */
+  getToolSchemas() {
+    const schemas = [];
+    const paramSchemas = {
+      file_read: { path: { type: "string", description: "File path" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } },
+      file_write: { path: { type: "string", description: "File path" }, content: { type: "string", description: "Content to write" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } },
+      file_edit: { path: { type: "string", description: "File path" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "Text to replace" }, new_string: { type: "string", description: "Replacement text" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } },
+      bash: { path: { type: "string", description: "" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "Shell command to execute" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } },
+      git_status: { path: { type: "string", description: "" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } },
+      git_diff: { path: { type: "string", description: "" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } },
+      git_commit: { path: { type: "string", description: "" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "Commit message" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } },
+      code_search: { path: { type: "string", description: "Search path" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "Search pattern (regex)" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } },
+      web_fetch: { path: { type: "string", description: "" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "URL to fetch" }, reasoning: { type: "string", description: "" } },
+      think: { path: { type: "string", description: "" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "Step-by-step reasoning" } },
+      list_files: { path: { type: "string", description: "Directory path" }, content: { type: "string", description: "" }, old_string: { type: "string", description: "" }, new_string: { type: "string", description: "" }, command: { type: "string", description: "" }, message: { type: "string", description: "" }, pattern: { type: "string", description: "" }, url: { type: "string", description: "" }, reasoning: { type: "string", description: "" } }
+    };
+    for (const [, tool] of this.tools) {
+      const props = {};
+      const required = [];
+      const params = paramSchemas[tool.name];
+      if (params) {
+        for (const [key, val] of Object.entries(params)) {
+          if (val.description) {
+            props[key] = val;
+            required.push(key);
+          }
+        }
+      }
+      schemas.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: {
+            type: "object",
+            properties: props,
+            required: required.length > 0 ? required : void 0
+          }
+        }
+      });
+    }
+    return schemas;
+  }
+  // ── Tool implementations ──
+  validatePath(resolved) {
+    const normalized = resolve(resolved);
+    if (!normalized.startsWith(PROJECT_ROOT)) {
+      throw new Error(`Path traversal blocked: '${resolved}' is outside project`);
+    }
+  }
+  fileRead(path) {
+    if (!path) return "Error: path is required";
+    const resolved = resolve(PROJECT_ROOT, path);
+    try {
+      this.validatePath(resolved);
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : "invalid path"}`;
+    }
+    if (!existsSync2(resolved)) return `Error: File not found: ${path}`;
+    return readFileSync(resolved, "utf-8");
+  }
+  fileWrite(path, content) {
+    if (!path || content === void 0) return "Error: path and content are required";
+    const resolved = resolve(PROJECT_ROOT, path);
+    try {
+      this.validatePath(resolved);
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : "invalid path"}`;
+    }
+    writeFileSync(resolved, content, "utf-8");
+    return `Written ${content.length} bytes to ${path}`;
+  }
+  fileEdit(path, oldString, newString) {
+    if (!path || !oldString || newString === void 0) return "Error: path, old_string, and new_string are required";
+    const resolved = resolve(PROJECT_ROOT, path);
+    try {
+      this.validatePath(resolved);
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : "invalid path"}`;
+    }
+    if (!existsSync2(resolved)) return `Error: File not found: ${path}`;
+    let content = readFileSync(resolved, "utf-8");
+    if (!content.includes(oldString)) return `Error: old_string not found in ${path}`;
+    content = content.replace(oldString, newString);
+    writeFileSync(resolved, content, "utf-8");
+    return `Edited ${path}: replaced "${oldString}" with "${newString}"`;
+  }
+  execBash(command) {
+    if (!command) return "Error: command is required";
+    for (const blocked of BLOCKED_COMMANDS) {
+      if (command.toLowerCase().includes(blocked.toLowerCase())) {
+        this.db.logAudit("blocked_command", command, false);
+        return `Error: Command blocked for security: matches pattern "${blocked}"`;
+      }
+    }
+    try {
+      const result = execSync(command, {
+        cwd: process.cwd(),
+        timeout: 3e4,
+        maxBuffer: 1048576,
+        encoding: "utf-8",
+        shell: process.platform === "win32" ? "cmd.exe" : "/bin/bash"
+      });
+      return result || "(command completed with no output)";
+    } catch (error) {
+      if (error instanceof Error) {
+        return `Error: ${error.message}`;
+      }
+      return "Error: Command execution failed";
+    }
+  }
+  execGit(args) {
+    try {
+      const result = execSync(`git ${args.join(" ")}`, {
+        cwd: process.cwd(),
+        timeout: 1e4,
+        maxBuffer: 1048576,
+        encoding: "utf-8"
+      });
+      return result || "(git command completed with no output)";
+    } catch (error) {
+      if (error instanceof Error) {
+        return `Git error: ${error.message}`;
+      }
+      return "Git error: Command failed";
+    }
+  }
+  searchCode(pattern, path = ".") {
+    if (!pattern) return "Error: pattern is required";
+    const isWin = process.platform === "win32";
+    const searchCmd = isWin ? `findstr /n /i /c:"${pattern}" "${resolve(PROJECT_ROOT, path)}\\*"` : `rg -n "${pattern}" "${resolve(PROJECT_ROOT, path)}" --max-count 20`;
+    try {
+      const result = execSync(searchCmd, {
+        cwd: PROJECT_ROOT,
+        timeout: 1e4,
+        maxBuffer: 1048576,
+        encoding: "utf-8",
+        shell: isWin ? "cmd.exe" : "/bin/bash"
+      });
+      return result || "No matches found.";
+    } catch {
+      return "No matches found.";
+    }
+  }
+  async webFetch(url) {
+    if (!url) return "Error: url is required";
+    try {
+      const parsed = new URL(url);
+      const blockedHosts = ["localhost", "127.0.0.1", "0.0.0.0", "::1"];
+      if (blockedHosts.includes(parsed.hostname)) {
+        return "Error: Cannot fetch from localhost for security reasons.";
+      }
+    } catch {
+      return "Error: Invalid URL";
+    }
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+      const text = await response.text();
+      return text.slice(0, 1e4);
+    } catch (error) {
+      return `Error fetching URL: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  }
+  listDir(path = ".") {
+    const resolved = resolve(PROJECT_ROOT, path);
+    try {
+      this.validatePath(resolved);
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : "invalid path"}`;
+    }
+    if (!existsSync2(resolved)) return `Error: Directory not found: ${path}`;
+    const isWin = process.platform === "win32";
+    const cmd = isWin ? `dir /b "${resolved}"` : `ls -la "${resolved}"`;
+    try {
+      const result = execSync(cmd, {
+        timeout: 5e3,
+        maxBuffer: 1e4,
+        encoding: "utf-8",
+        shell: isWin ? "cmd.exe" : "/bin/bash"
+      });
+      return result;
+    } catch {
+      return `Error: Could not list directory ${path}`;
+    }
+  }
+};
+
+// src/skills/self-improve/engine.ts
+import { writeFileSync as writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var SelfImprovementEngine = class {
+  db;
+  skillsDir;
+  constructor(db) {
+    this.db = db;
+    this.skillsDir = join2(homedir2(), ".config", "voracode", "skills");
+    if (!existsSync3(this.skillsDir)) {
+      mkdirSync2(this.skillsDir, { recursive: true });
+    }
+    this.ensureTables();
+  }
+  ensureTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS task_patterns (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        signature TEXT UNIQUE NOT NULL,
+        description TEXT NOT NULL,
+        tool_sequence TEXT NOT NULL,
+        files_changed TEXT,
+        commands_run TEXT,
+        success_count INTEGER DEFAULT 0,
+        failure_count INTEGER DEFAULT 0,
+        last_seen TEXT DEFAULT (datetime('now')),
+        suggested_skill INTEGER DEFAULT 0,
+        user_decision TEXT DEFAULT 'pending',
+        skill_path TEXT
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS user_preferences (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        category TEXT,
+        confidence REAL DEFAULT 0.5,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS skill_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        skill_name TEXT NOT NULL,
+        version INTEGER DEFAULT 1,
+        action TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+  }
+  /**
+   * Record a completed task and check for patterns
+   */
+  recordTask(description, toolsUsed, filesChanged, commandsRun, success3) {
+    const signature = this.createSignature(toolsUsed, description);
+    const existing = this.db.query(
+      "SELECT * FROM task_patterns WHERE signature = ?"
+    ).get(signature);
+    if (existing) {
+      const newSuccess = existing.success_count + (success3 ? 1 : 0);
+      const newFailure = existing.failure_count + (success3 ? 0 : 1);
+      const total = newSuccess + newFailure;
+      const successRate = total > 0 ? newSuccess / total : 0;
+      this.db.run(
+        `UPDATE task_patterns SET 
+         success_count = ?, failure_count = ?, last_seen = datetime('now')
+         WHERE signature = ?`,
+        [newSuccess, newFailure, signature]
+      );
+      if (total >= 3 && successRate >= 0.8 && !existing.suggested_skill) {
+        const pattern = {
+          id: existing.id,
+          signature,
+          description: existing.description,
+          toolSequence: JSON.parse(existing.tool_sequence),
+          filesChanged: JSON.parse(existing.files_changed || "[]"),
+          commandsRun: JSON.parse(existing.commands_run || "[]"),
+          successCount: newSuccess,
+          failureCount: newFailure,
+          lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+          suggestedSkill: true,
+          userDecision: "pending"
+        };
+        this.db.run("UPDATE task_patterns SET suggested_skill = 1 WHERE signature = ?", [signature]);
+        return pattern;
+      }
+      return null;
+    }
+    this.db.run(
+      `INSERT INTO task_patterns 
+       (signature, description, tool_sequence, files_changed, commands_run, success_count, failure_count)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [
+        signature,
+        description,
+        JSON.stringify(toolsUsed),
+        JSON.stringify(filesChanged),
+        JSON.stringify(commandsRun),
+        success3 ? 1 : 0,
+        success3 ? 0 : 1
+      ]
+    );
+    return null;
+  }
+  /**
+   * Create a pattern signature from tools and task description
+   */
+  createSignature(toolsUsed, description) {
+    const tools = toolsUsed.map((t) => t.toLowerCase()).sort().join(",");
+    const taskType = this.classifyTask(description);
+    return `${taskType}|${tools}`;
+  }
+  /**
+   * Classify a task into a category
+   */
+  classifyTask(description) {
+    const d = description.toLowerCase();
+    if (d.includes("create") || d.includes("new") || d.includes("make")) return "create";
+    if (d.includes("fix") || d.includes("bug") || d.includes("error")) return "fix";
+    if (d.includes("refactor") || d.includes("optimize") || d.includes("improve")) return "refactor";
+    if (d.includes("test") || d.includes("spec")) return "test";
+    if (d.includes("deploy") || d.includes("publish")) return "deploy";
+    if (d.includes("explain") || d.includes("understand") || d.includes("how")) return "explain";
+    return "general";
+  }
+  /**
+   * Generate a SKILL.md from a pattern
+   */
+  generateSkill(pattern) {
+    const skillName = pattern.description.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "learned-skill";
+    const skillDir = join2(this.skillsDir, skillName);
+    mkdirSync2(skillDir, { recursive: true });
+    const skillPath = join2(skillDir, "SKILL.md");
+    const content = `---
+name: ${skillName}
+description: Auto-learned skill for: ${pattern.description}
+version: 1.0.0
+source: learned
+---
+
+## When to use
+Use this skill when performing: ${pattern.description}
+
+## Pattern discovered
+- Tools used: ${pattern.toolSequence.join(", ")}
+- Success rate: ${(pattern.successCount / (pattern.successCount + pattern.failureCount) * 100).toFixed(0)}%
+- Times seen: ${pattern.successCount + pattern.failureCount}
+
+## Instructions
+1. Follow the same tool sequence that worked before
+2. Apply to the specific project structure
+3. Verify the result matches expectations
+
+## Notes
+- This skill was auto-generated by VORACODE's self-improvement engine
+- You can edit or delete it: voracode skill remove ${skillName}
+- Rollback: voracode skill history ${skillName}
+`;
+    writeFileSync2(skillPath, content, "utf-8");
+    this.db.run(
+      "INSERT INTO skill_history (skill_name, version, action, content) VALUES (?, ?, ?, ?)",
+      [skillName, 1, "created", content]
+    );
+    this.db.run(
+      "UPDATE task_patterns SET skill_path = ?, user_decision = 'accepted' WHERE signature = ?",
+      [skillPath, pattern.signature]
+    );
+    return skillName;
+  }
+  /**
+   * User rejects a suggested skill
+   */
+  rejectPattern(signature, permanently = false) {
+    this.db.run(
+      "UPDATE task_patterns SET user_decision = ? WHERE signature = ?",
+      [permanently ? "never" : "rejected", signature]
+    );
+  }
+  /**
+   * Record a user preference
+   */
+  recordPreference(key, value, category = "general") {
+    this.db.run(
+      `INSERT OR REPLACE INTO user_preferences 
+       (key, value, category, updated_at) VALUES (?, ?, ?, datetime('now'))`,
+      [key, value, category]
+    );
+  }
+  /**
+   * Get all learned patterns
+   */
+  getPatterns() {
+    const rows = this.db.query("SELECT * FROM task_patterns ORDER BY last_seen DESC").all();
+    return rows.map((r) => ({
+      id: r.id,
+      signature: r.signature,
+      description: r.description,
+      toolSequence: JSON.parse(r.tool_sequence),
+      filesChanged: JSON.parse(r.files_changed || "[]"),
+      commandsRun: JSON.parse(r.commands_run || "[]"),
+      successCount: r.success_count || 0,
+      failureCount: r.failure_count || 0,
+      lastSeen: r.last_seen || (/* @__PURE__ */ new Date()).toISOString(),
+      suggestedSkill: Boolean(r.suggested_skill),
+      userDecision: r.user_decision || "pending",
+      skillPath: r.skill_path
+    }));
+  }
+  /**
+   * Get user preferences
+   */
+  getPreferences() {
+    const rows = this.db.query("SELECT key, value FROM user_preferences").all();
+    const prefs = {};
+    for (const r of rows) {
+      prefs[r.key] = r.value;
+    }
+    return prefs;
+  }
+  /**
+   * Rollback a skill to a previous version
+   */
+  rollbackSkill(skillName) {
+    const history = this.db.query(
+      "SELECT * FROM skill_history WHERE skill_name = ? ORDER BY created_at DESC LIMIT 2"
+    ).all(skillName);
+    if (history.length < 2) return false;
+    const previousVersion = history[1];
+    const skillDir = join2(this.skillsDir, skillName);
+    const skillPath = join2(skillDir, "SKILL.md");
+    if (existsSync3(skillPath)) {
+      writeFileSync2(skillPath, previousVersion.content, "utf-8");
+      this.db.run(
+        "INSERT INTO skill_history (skill_name, version, action, content) VALUES (?, ?, ?, ?)",
+        [skillName, previousVersion.version + 1, "rollback", previousVersion.content]
+      );
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get storage statistics
+   */
+  getStats() {
+    const patterns = this.db.query("SELECT COUNT(*) as c FROM task_patterns").get().c;
+    const preferences = this.db.query("SELECT COUNT(*) as c FROM user_preferences").get().c;
+    const skills = this.db.query("SELECT COUNT(*) as c FROM task_patterns WHERE skill_path IS NOT NULL").get().c;
+    const storageKB = Math.round((patterns * 2 + preferences * 0.1) * 10) / 10;
+    return { patterns, preferences, skills, storageKB };
+  }
+};
+
+// src/engine/agent.ts
+var Agent = class {
+  router;
+  db;
+  tools;
+  sie;
+  systemPrompt;
+  constructor() {
+    this.router = new ModelRouter();
+    this.db = new VoraDatabase();
+    this.tools = new ToolExecutor(this.db);
+    this.sie = new SelfImprovementEngine(this.db);
+    this.systemPrompt = this.buildSystemPrompt();
+  }
+  buildSystemPrompt() {
+    return `You are VORACODE, an AI engineering partner that lives in the terminal.
+
+You help users with coding tasks. You have access to real tools that let you read, write, and execute code.
+
+## How you work
+1. Understand what the user wants
+2. Use tools to explore the project when needed
+3. Plan the changes
+4. Execute step by step using the tools available to you
+5. Tell the user when you're done
+
+## Rules
+- NEVER execute dangerous commands (rm -rf /, sudo, mkfs, dd, fork bombs)
+- NEVER output API keys, passwords, or secrets
+- Show what you're doing before doing it
+- Ask the user before destructive operations
+- Use the think tool to reason through complex problems before acting
+- When the task is complete, summarize what you did
+
+## Available Tools
+You have file_read, file_write, file_edit, bash, git_status, git_diff, git_commit,
+code_search, web_fetch, think, and list_files at your disposal.
+Use them to accomplish the task. Do NOT just describe what to do \u2014 USE the tools.
+
+When the task is complete, summarize what was done.`;
+  }
+  /**
+   * Run the agent loop with full tool-calling
+   */
+  async runTurn(sessionId, userMessage, modelRef, options) {
+    const startTime = Date.now();
+    const maxTurns = options?.maxTurns || 15;
+    let totalTokens = 0;
+    let turns = 0;
+    let steps = 0;
+    let toolOnlyTurns = 0;
+    const toolSchemas = this.tools.getToolSchemas();
+    const messages = [
+      { role: "system", content: this.systemPrompt },
+      { role: "user", content: userMessage }
+    ];
+    this.db.addMessage(sessionId, "user", userMessage);
+    const toolsUsed = [];
+    const filesChanged = [];
+    const commandsRun = [];
+    try {
+      while (turns < maxTurns) {
+        turns++;
+        const chatOptions = {
+          model: modelRef,
+          maxTokens: 2048,
+          temperature: 0.3,
+          tools: toolSchemas,
+          toolChoice: "auto"
+        };
+        const response = await this.router.chat(modelRef, messages, chatOptions);
+        totalTokens += response.usage.totalTokens;
+        this.db.recordApiCall(response.usage.inputTokens, response.usage.outputTokens);
+        if (response.content) {
+          this.db.addMessage(sessionId, "assistant", response.content, response.usage.totalTokens);
+        }
+        if (response.toolCalls && response.toolCalls.length > 0) {
+          toolOnlyTurns++;
+          if (toolOnlyTurns > 10) {
+            return {
+              success: true,
+              content: "Task reached maximum tool iterations. Results so far are applied.",
+              sessionId,
+              tokensUsed: totalTokens,
+              turns,
+              steps
+            };
+          }
+          messages.push({
+            role: "assistant",
+            content: response.content || "",
+            tool_calls: response.toolCalls
+          });
+          for (const toolCall of response.toolCalls) {
+            steps++;
+            toolsUsed.push(toolCall.function.name);
+            try {
+              const args = JSON.parse(toolCall.function.arguments);
+              if ((toolCall.function.name === "file_write" || toolCall.function.name === "file_edit") && args.path) {
+                filesChanged.push(args.path);
+              }
+              if (toolCall.function.name === "bash" && args.command) {
+                commandsRun.push(args.command);
+              }
+            } catch {
+            }
+            let result;
+            let error = false;
+            try {
+              result = await this.tools.execute(toolCall.function.name, toolCall.function.arguments);
+            } catch (e) {
+              result = `Error: ${e instanceof Error ? e.message : String(e)}`;
+              error = true;
+            }
+            const resultStr = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+            const truncated = resultStr.length > 5e3 ? resultStr.slice(0, 5e3) + "\n... (truncated)" : resultStr;
+            this.db.logAudit(
+              error ? "tool_error" : "tool_execute",
+              JSON.stringify({ tool: toolCall.function.name }),
+              !error
+            );
+            messages.push({
+              role: "tool",
+              content: truncated,
+              tool_call_id: toolCall.id
+            });
+          }
+          continue;
+        }
+        this.db.updateSession(sessionId, {
+          total_tokens: totalTokens,
+          total_turns: turns,
+          status: "completed"
+        });
+        let patternSuggestion;
+        if (toolsUsed.length > 0) {
+          const pattern = this.sie.recordTask(
+            userMessage,
+            toolsUsed,
+            filesChanged,
+            commandsRun,
+            true
+            // success
+          );
+          if (pattern) {
+            patternSuggestion = `
+
+\u{1F4A1} VORACODE noticed you've done this ${pattern.successCount + 1} times with ${(pattern.successCount / (pattern.successCount + pattern.failureCount) * 100).toFixed(0)}% success.
+   Would you like me to create a reusable skill for this?
+   Run: voracode skill create ${pattern.description.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 30)}`;
+          }
+        }
+        return {
+          success: true,
+          content: response.content + (patternSuggestion || ""),
+          sessionId,
+          tokensUsed: totalTokens,
+          turns,
+          steps,
+          patternSuggestion
+        };
+      }
+      this.db.updateSession(sessionId, {
+        total_tokens: totalTokens,
+        total_turns: turns,
+        status: "completed"
+      });
+      return {
+        success: true,
+        content: "Task reached maximum turns. You can continue with more instructions.",
+        sessionId,
+        tokensUsed: totalTokens,
+        turns,
+        steps
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.db.logAudit("agent_error", errorMsg, false);
+      this.db.updateSession(sessionId, { status: "error" });
+      return {
+        success: false,
+        content: "",
+        sessionId,
+        tokensUsed: totalTokens,
+        turns,
+        steps,
+        error: errorMsg
+      };
+    }
+  }
+};
+
+// src/session/manager.ts
+var SessionManager = class {
+  db;
+  router;
+  agent;
+  constructor() {
+    this.db = new VoraDatabase();
+    this.router = new ModelRouter();
+    this.agent = new Agent();
+  }
+  /**
+   * Create a new session
+   */
+  create(modelRef) {
+    const provider = modelRef ? this.router.detectProvider(modelRef) : "auto";
+    const modelName = modelRef || "auto";
+    return this.db.createSession(provider, modelName);
+  }
+  /**
+   * Resume an existing session
+   */
+  getSession(id) {
+    const session = this.db.getSession(id);
+    if (!session) return null;
+    return {
+      id: session.id,
+      title: session.title,
+      modelProvider: session.model_provider,
+      modelName: session.model_name,
+      totalTokens: session.total_tokens || 0,
+      totalTurns: session.total_turns || 0,
+      status: session.status,
+      createdAt: session.created_at,
+      updatedAt: session.updated_at
+    };
+  }
+  /**
+   * List all sessions
+   */
+  list(limit = 10) {
+    return this.db.listSessions(limit).map((s) => ({
+      id: s.id,
+      title: s.title,
+      modelProvider: s.model_provider,
+      modelName: s.model_name,
+      totalTokens: s.total_tokens || 0,
+      totalTurns: s.total_turns || 0,
+      status: s.status,
+      createdAt: s.created_at,
+      updatedAt: s.updated_at
+    }));
+  }
+  /**
+   * Delete a session
+   */
+  delete(id) {
+    this.db.deleteSession(id);
+  }
+  /**
+   * Run a task in a session
+   */
+  async run(sessionId, message, modelRef, options) {
+    return this.agent.runTurn(sessionId, message, modelRef, options);
+  }
+  /**
+   * Fork a session (create new from existing)
+   */
+  fork(id) {
+    const original = this.getSession(id);
+    if (!original) return null;
+    const newId = this.db.createSession(original.modelProvider, original.modelName, `${original.title} (fork)`);
+    return newId;
+  }
+  /**
+   * Get messages for a session
+   */
+  getMessages(sessionId) {
+    return this.db.getMessages(sessionId);
+  }
+  /**
+   * Get database path
+   */
+  getDbPath() {
+    return this.db.getDbPath();
+  }
+};
+
+// package.json
+var version = "0.0.1";
+
+// src/ui/theme.ts
+var VERSION = version || "0.0.1";
+var c = {
+  // Primary
+  brand: "\x1B[38;2;155;89;182m",
+  // Purple (#9b59b6)
+  brandLight: "\x1B[38;2;186;135;205m",
+  // Light purple
+  // Status
+  success: "\x1B[38;2;46;204;113m",
+  // Mint green
+  error: "\x1B[38;2;231;76;60m",
+  // Coral red
+  warning: "\x1B[38;2;241;196;15m",
+  // Warm gold
+  info: "\x1B[38;2;52;152;219m",
+  // Sky blue
+  // Text
+  white: "\x1B[38;2;255;255;255m",
+  dim: "\x1B[38;2;149;165;166m",
+  // Slate
+  bright: "\x1B[38;2;189;195;199m",
+  // Silver
+  muted: "\x1B[38;2;127;140;141m",
+  // Gray
+  // Accent
+  cyan: "\x1B[38;2;0;184;212m",
+  orange: "\x1B[38;2;230;126;34m",
+  pink: "\x1B[38;2;236;100;175m",
+  teal: "\x1B[38;2;0;184;148m",
+  // Reset
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim2: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m"
+};
+var icon = {
+  check: `${c.success}\u25CF${c.reset}`,
+  cross: `${c.error}\u25CF${c.reset}`,
+  warn: `${c.warning}\u25CF${c.reset}`,
+  info: `${c.info}\u25CF${c.reset}`,
+  arrow: `${c.brand}\u2192${c.reset}`,
+  dot: `${c.dim}\xB7${c.reset}`,
+  diamond: `${c.brand}\u25C6${c.reset}`,
+  star: `${c.warning}\u2605${c.reset}`,
+  bolt: `${c.cyan}\u26A1${c.reset}`,
+  shield: `${c.teal}\u25C7${c.reset}`,
+  key: `${c.orange}\u25C7${c.reset}`,
+  brain: `${c.purple || c.pink}\u25C8${c.reset}`
+};
+function divider(char = "\u2500", width = 48) {
+  return `${c.dim}${char.repeat(width)}${c.reset}`;
+}
+function success(text) {
+  return `${icon.check}  ${text}`;
+}
+function printBanner() {
+  console.log(`
+  ${c.brand}    \u25C6${c.reset}   ${c.bold}V O R A C O D E${c.reset}   ${c.brand}\u25C6${c.reset}
+
+  ${c.dim}Your AI engineering partner.${c.reset}
+  ${c.dim}One agent, every surface.${c.reset}
+
+  ${c.muted}v${VERSION}${c.reset}  ${c.dim}\xB7${c.reset}  ${c.muted}${(/* @__PURE__ */ new Date()).toLocaleDateString() + " " + (/* @__PURE__ */ new Date()).toLocaleTimeString()}${c.reset}
+  `);
+}
+function commandBanner(title, subtitle) {
+  console.log(`
+  ${c.brand}\u25C6${c.reset}  ${c.bold}${title}${c.reset}
+  ${c.dim}${subtitle || ""}${c.reset}
+  `);
+}
+function statusLine(label, value, type = "info") {
+  const colorMap = { success: c.success, error: c.error, warning: c.warning, info: c.info, dim: c.dim };
+  return `  ${c.dim}${label.padEnd(20)}${c.reset}  ${colorMap[type]}${value}${c.reset}`;
+}
+function footer() {
+  console.log(`
+  ${c.dim}${c.brand}\u25C6${c.reset}  ${c.muted}voracode${c.reset}  ${c.dim}|${c.reset}  ${c.muted}github.com/mysterious75/voracode${c.reset}  ${c.dim}|${c.reset}  ${c.muted}MIT${c.reset}
+  `);
+}
+
+// src/cli/run.ts
+var runCommand = new Command("run").description("Execute a task with AI").argument("[message]", "Task description").option("-m, --model <model>", "Model to use (provider/model-name)").option("-a, --agent <agent>", "Agent mode (build|plan|debug)").option("-y, --yes", "Auto-approve all actions").option("--session <id>", "Continue an existing session").option("--fork", "Fork session when continuing").option("--output <format>", "Output format (text|json|silent)", "text").option("--dry-run", "Show plan without executing").action(async (message, options) => {
+  if (!message) {
+    console.error(`
+  ${c.error}\u2716 Please provide a task description.${c.reset}
+`);
+    console.error(`  ${c.dim}Usage: ${c.brand}${c.bold}voracode${c.reset}${c.dim} run "your task here"${c.reset}
+`);
+    process.exit(1);
+  }
+  const sessions = new SessionManager();
+  const router = new ModelRouter();
+  const db = new VoraDatabase();
+  let modelRef = options.model || "openrouter/openrouter/free";
+  if (options.model) {
+    modelRef = options.model.includes("/") ? options.model : `${router.detectProvider(options.model)}/${options.model}`;
+  }
+  const provider = modelRef.split("/")[0];
+  if (!router.hasValidKey(provider)) {
+    console.log(`
+  ${c.warning}\u25C6${c.reset}  No API key for ${c.bold}${provider}${c.reset}`);
+    console.log(`  ${c.dim}Configure: voracode key set ${provider} <your-api-key>${c.reset}
+`);
+    process.exit(1);
+  }
+  let sessionId;
+  if (options.session) {
+    const existing = sessions.getSession(options.session);
+    if (!existing) {
+      console.error(`
+  ${c.error}\u2716 Session not found: ${options.session}${c.reset}
+`);
+      process.exit(1);
+    }
+    sessionId = options.fork ? sessions.fork(options.session) || sessions.create(modelRef) : options.session;
+  } else {
+    sessionId = sessions.create(modelRef);
+  }
+  const isSilent = options.output === "silent";
+  const isJson = options.output === "json";
+  if (!isSilent && !isJson) {
+    console.log(`
+  ${c.brand}\u25C6${c.reset}  ${c.bold}Running${c.reset}  ${c.dim}${message}${c.reset}`);
+    console.log(`  ${c.dim}Model:${c.reset} ${modelRef}`);
+    console.log(`  ${c.dim}Session:${c.reset} ${sessionId.slice(0, 8)}...
+`);
+    if (options["dry-run"]) {
+      console.log(`  ${c.warning}\u25C6${c.reset}  ${c.dim}Dry-run mode \u2014 no execution${c.reset}
+`);
+    }
+  }
+  try {
+    const result = await sessions.run(sessionId, message, modelRef, { maxTurns: 25 });
+    if (isJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (isSilent) {
+      console.log(result.content);
+    } else {
+      if (result.success) {
+        console.log(`  ${c.success}${c.bold} Completed${c.reset}  ${c.dim}${result.turns} turns \xB7 ${result.steps} steps \xB7 ${result.tokensUsed} tokens${c.reset}
+`);
+        console.log(result.content);
+        if (result.patternSuggestion) {
+          console.log(`
+  ${c.cyan}\u25C6${c.reset}  ${c.dim}VORACODE noticed a pattern \u2014 run ${c.bold}voracode skill patterns${c.reset}${c.dim} to see${c.reset}`);
+        }
+        console.log(`
+  ${c.dim}Session: ${c.brand}${sessionId.slice(0, 8)}${c.reset}`);
+        console.log(`  ${c.dim}Data: ${sessions.getDbPath()}${c.reset}
+`);
+      } else {
+        console.log(`
+  ${c.error}\u2716 ${result.error || "Task failed"}${c.reset}
+`);
+        process.exit(1);
+      }
+    }
+  } catch (error) {
+    console.error(`
+  ${c.error}\u2716 ${error instanceof Error ? error.message : String(error)}${c.reset}
+`);
+    process.exit(1);
+  }
+  footer();
+});
+
+// src/cli/init.ts
+import { Command as Command2 } from "commander";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+var initCommand = new Command2("init").description("Initialize VORACODE in current project").argument("[directory]", "Project directory", ".").option("-f, --force", "Overwrite existing configuration").option("--name <name>", "Project name").action(async (directory, options) => {
+  const projectPath = resolve2(directory);
+  if (!existsSync4(projectPath)) {
+    console.error(`
+  ${c.error}\u2716 Directory not found: ${projectPath}${c.reset}
+`);
+    process.exit(1);
+  }
+  const voracodeDir = join3(projectPath, ".voracode");
+  const projectName = options.name || projectPath.split(/[/\\]/).pop() || "project";
+  if (existsSync4(voracodeDir) && !options.force) {
+    console.log(`
+  ${c.info}\u25C6${c.reset} Already initialized. Use ${c.bold}--force${c.reset} to reinitialize.
+`);
+    return;
+  }
+  mkdirSync3(join3(voracodeDir, "skills"), { recursive: true });
+  mkdirSync3(join3(voracodeDir, "plugins"), { recursive: true });
+  mkdirSync3(join3(voracodeDir, "mcp"), { recursive: true });
+  writeFileSync3(join3(voracodeDir, "AGENTS.md"), `# VORACODE \u2014 ${projectName}
+
+## Project Overview
+Describe your project here.
+
+## Conventions
+- Coding style
+- Testing approach
+- Commit format
+
+## Environment
+- Runtime versions
+- Build commands
+`);
+  const config = {
+    $schema: "https://voracode.dev/schemas/config.json",
+    version: "1.0",
+    project: { name: projectName, path: projectPath },
+    model: { provider: "auto", name: "auto", fallback: ["deepseek", "groq"] },
+    context: { maxTokens: 128e3, compression: "auto", smartLoading: true },
+    security: { sandbox: { enabled: true, timeout: 3e4, maxOutput: 1048576 } },
+    skills: { dirs: ["~/.config/voracode/skills", ".voracode/skills"], autoLearn: false },
+    telemetry: { enabled: false, localOnly: true }
+  };
+  writeFileSync3(join3(voracodeDir, "config.json"), JSON.stringify(config, null, 2));
+  console.log(`
+  ${success(`Initialized in ${c.brand}${c.bold}.voracode/${c.reset}`)}
+`);
+  console.log(statusLine("AGENTS.md", "Project instructions", "info"));
+  console.log(statusLine("config.json", "Configuration", "info"));
+  console.log(statusLine("skills/", "Custom skills", "info"));
+  console.log(statusLine("plugins/", "Extensions", "info"));
+  console.log(statusLine("mcp/", "MCP servers", "info"));
+  console.log(`
+  ${c.dim}Next steps:${c.reset}`);
+  console.log(`  ${c.brand}1.${c.reset} Edit ${c.bold}.voracode/AGENTS.md${c.reset}`);
+  console.log(`  ${c.brand}2.${c.reset} Set API key: ${c.bold}voracode key set${c.reset}`);
+  console.log(`  ${c.brand}3.${c.reset} Start: ${c.bold}voracode run "your task"${c.reset}
+`);
+});
+
+// src/cli/session.ts
+import { Command as Command3 } from "commander";
+var getManager = () => new SessionManager();
+var sessionCommand = new Command3("session").description("Manage AI agent sessions").addCommand(
+  new Command3("list").description("List all sessions").option("--limit <number>", "Max sessions to show", "10").action(async (options) => {
+    const sessions = getManager();
+    const list = sessions.list(Number(options.limit));
+    if (list.length === 0) {
+      console.log("\n  \u{1F4CB} No sessions yet. Run 'voracode run' to create one.\n");
+      return;
+    }
+    console.log(`
+  \u{1F4CB} Recent sessions (last ${options.limit}):
+`);
+    for (const s of list) {
+      const date = (/* @__PURE__ */ new Date(s.createdAt + "Z")).toLocaleString();
+      console.log(`  \u{1F194} ${s.id.slice(0, 8)}... | ${s.title.slice(0, 40).padEnd(40)} | ${s.status.padEnd(10)} | ${date}`);
+    }
+    console.log(`
+  Total: ${list.length} session(s)
+`);
+  })
+).addCommand(
+  new Command3("show").description("Show session details").argument("<id>", "Session ID").action(async (id) => {
+    const sessions = getManager();
+    const session = sessions.getSession(id);
+    if (!session) {
+      console.error(`
+  \u2716 Session not found: ${id}
+`);
+      process.exit(1);
+    }
+    console.log(`
+  \u{1F4C4} Session: ${id}`);
+    console.log(`  Title: ${session.title}`);
+    console.log(`  Model: ${session.modelProvider}/${session.modelName}`);
+    console.log(`  Status: ${session.status}`);
+    console.log(`  Tokens: ${session.totalTokens}`);
+    console.log(`  Turns: ${session.totalTurns}`);
+    console.log(`  Created: ${session.createdAt}`);
+    console.log(`  Updated: ${session.updatedAt}`);
+    const messages = sessions.getMessages(id);
+    console.log(`  Messages: ${messages.length}
+`);
+  })
+).addCommand(
+  new Command3("resume").description("Resume an existing session").argument("<id>", "Session ID to resume").option("-f, --fork", "Fork into a new session").action(async (id, options) => {
+    const sessions = getManager();
+    const session = sessions.getSession(id);
+    if (!session) {
+      console.error(`
+  \u2716 Session not found: ${id}
+`);
+      process.exit(1);
+    }
+    if (options.fork) {
+      const newId = sessions.fork(id);
+      if (newId) {
+        console.log(`
+  \u{1F33F} Forked session ${id.slice(0, 8)}... \u2192 ${newId.slice(0, 8)}...`);
+        console.log(`  Run: voracode run "your task" --session ${newId}
+`);
+      }
+    } else {
+      console.log(`
+  \u{1F504} Resuming session ${id.slice(0, 8)}...`);
+      console.log(`  Last turn: ${session.totalTurns} turns, ${session.totalTokens} tokens`);
+      console.log(`  Run: voracode run "your task" --session ${id}
+`);
+    }
+  })
+).addCommand(
+  new Command3("delete").description("Delete a session").argument("<id>", "Session ID to delete").option("-f, --force", "Skip confirmation").action(async (id) => {
+    const sessions = getManager();
+    const session = sessions.getSession(id);
+    if (!session) {
+      console.error(`
+  \u2716 Session not found: ${id}
+`);
+      process.exit(1);
+    }
+    sessions.delete(id);
+    console.log(`
+  \u{1F5D1}\uFE0F  Session ${id.slice(0, 8)}... deleted.
+`);
+  })
+).addCommand(
+  new Command3("export").description("Export session as JSON").argument("<id>", "Session ID to export").argument("[file]", "Output file path").action(async (id, file) => {
+    const sessions = getManager();
+    const session = sessions.getSession(id);
+    if (!session) {
+      console.error(`
+  \u2716 Session not found: ${id}
+`);
+      process.exit(1);
+    }
+    const messages = sessions.getMessages(id);
+    const data = JSON.stringify({ session, messages }, null, 2);
+    if (file) {
+      await Bun.write(file, data);
+      console.log(`
+  \u{1F4BE} Session exported to ${file}
+`);
+    } else {
+      console.log(data);
+    }
+  })
+).addCommand(
+  new Command3("import").description("Import session from JSON").argument("<file>", "JSON file path or URL").action(async (file) => {
+    console.log(`
+  \u{1F4E5} Importing session from ${file}
+`);
+  })
+);
+
+// src/cli/model.ts
+import { Command as Command4 } from "commander";
+var modelCommand = new Command4("model").description("Manage AI providers and models").addCommand(
+  new Command4("list").description("List available providers and models").option("-p, --provider <name>", "Filter by provider").action(async (options) => {
+    const router = new ModelRouter();
+    console.log("\n  \u{1F4E1} Available AI Providers:\n");
+    if (options.provider) {
+      const models = router.getModels(options.provider);
+      const hasKey = router.hasValidKey(options.provider);
+      console.log(`  Provider: ${options.provider}`);
+      console.log(`  Key: ${hasKey ? "\u2705 configured" : "\u274C not configured"}`);
+      console.log(`  Models:`);
+      for (const m of models) {
+        console.log(`    \u2022 ${m}`);
+      }
+      console.log();
+      return;
+    }
+    const providers = [
+      { name: "OpenAI-compatible", protocols: "openai, deepseek, groq, together, ollama, openrouter, huggingface, fireworks, cerebras" },
+      { name: "Anthropic Messages", protocols: "anthropic" },
+      { name: "Google AI", protocols: "google" },
+      { name: "Custom", protocols: "Any OpenAI-compatible endpoint" }
+    ];
+    console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+    console.log("  \u2502 Protocol             \u2502 Providers                                    \u2502");
+    console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+    for (const p of providers) {
+      console.log(`  \u2502 ${p.name.padEnd(20)} \u2502 ${p.protocols.padEnd(43)} \u2502`);
+    }
+    console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+    console.log("\n  \u{1F511} Key Status:");
+    for (const name of ["openai", "anthropic", "deepseek", "groq", "google", "openrouter"]) {
+      const status = router.hasValidKey(name) ? "\u2705" : "\u274C";
+      console.log(`  ${status} ${name}`);
+    }
+    console.log("\n  \u26A0\uFE0F  VORACODE is BYOK \u2014 no free managed models.");
+    console.log("  Configure: voracode key set <provider> <key>");
+    console.log("  Or set env: PROVIDER_API_KEY=sk-...\n");
+  })
+).addCommand(
+  new Command4("set").description("Set active model for session").argument("<model>", "Model identifier (provider/model-name)").action(async (model) => {
+    if (!model.includes("/")) {
+      console.error("\n  \u2716 Use format: provider/model-name");
+      console.error("  Example: voracode model set deepseek/deepseek-chat\n");
+      process.exit(1);
+    }
+    console.log(`
+  \u2705 Active model set to: ${model}
+`);
+  })
+).addCommand(
+  new Command4("test").description("Test connection to a provider").argument("[provider]", "Provider name").action(async (provider) => {
+    const router = new ModelRouter();
+    const name = provider || "deepseek";
+    const key = router.getKey(name);
+    if (!key) {
+      console.log(`
+  \u274C No API key for '${name}'`);
+      console.log(`  Configure: voracode key set ${name} <key>
+`);
+      return;
+    }
+    console.log(`
+  \u{1F50C} Testing: ${name}...`);
+    try {
+      const result = await router.chat(`${name}/test`, [
+        { role: "user", content: "Say 'ok' if you receive this." }
+      ], { maxTokens: 10 });
+      console.log(`  \u2705 Connection successful!`);
+      console.log(`  Response: ${result.content.slice(0, 100)}`);
+      console.log(`  Model: ${result.model}`);
+      console.log(`  Tokens: ${result.usage.totalTokens}
+`);
+    } catch (error) {
+      console.log(`  \u274C Connection failed:`);
+      console.log(`  ${error instanceof Error ? error.message : String(error)}
+`);
+    }
+  })
+);
+
+// src/cli/skill.ts
+import { Command as Command5 } from "commander";
+import { existsSync as existsSync5, readFileSync as readFileSync2, readdirSync } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+var skillCommand = new Command5("skill").description("Manage skills").alias("skills").addCommand(
+  new Command5("list").description("List available skills").action(async () => {
+    const skillsDir = join4(homedir3(), ".config", "voracode", "skills");
+    const builtinSkills = [
+      { name: "web-search", description: "Search the web for information", source: "builtin" },
+      { name: "web-fetch", description: "Fetch and extract web content", source: "builtin" },
+      { name: "research", description: "Multi-source research with synthesis", source: "builtin" },
+      { name: "code-review", description: "AI-powered code review", source: "builtin" },
+      { name: "git-helper", description: "Git automation assistance", source: "builtin" },
+      { name: "deploy", description: "One-command deployment templates", source: "builtin" },
+      { name: "learn", description: "Self-improvement pattern tracker", source: "builtin" }
+    ];
+    const learnedSkills = [];
+    if (existsSync5(skillsDir)) {
+      for (const dir of readdirSync(skillsDir)) {
+        const skillPath = join4(skillsDir, dir, "SKILL.md");
+        if (existsSync5(skillPath)) {
+          try {
+            const content = readFileSync2(skillPath, "utf-8");
+            const descMatch = content.match(/description:\s*(.+)/);
+            learnedSkills.push({
+              name: dir,
+              description: descMatch ? descMatch[1].trim() : "Learned skill",
+              source: "learned"
+            });
+          } catch {
+          }
+        }
+      }
+    }
+    console.log("\n  \u{1F6E0}\uFE0F  Available Skills:\n");
+    if (builtinSkills.length > 0) {
+      console.log("  Built-in:");
+      for (const s of builtinSkills) {
+        console.log(`    \u{1F4E6} ${s.name.padEnd(20)} ${s.description}`);
+      }
+    }
+    if (learnedSkills.length > 0) {
+      console.log("\n  Learned (auto-generated):");
+      for (const s of learnedSkills) {
+        console.log(`    \u{1F9E0} ${s.name.padEnd(20)} ${s.description}`);
+      }
+    }
+    console.log(`
+  Total: ${builtinSkills.length + learnedSkills.length} skills
+`);
+  })
+).addCommand(
+  new Command5("patterns").description("Show learning patterns detected").action(async () => {
+    const db = new VoraDatabase();
+    const sie = new SelfImprovementEngine(db);
+    const patterns = sie.getPatterns();
+    if (patterns.length === 0) {
+      console.log("\n  \u{1F9E0} No patterns detected yet.");
+      console.log("  Use VORACODE regularly \u2014 it will learn from your tasks.\n");
+      return;
+    }
+    console.log("\n  \u{1F9E0} Detected Patterns:\n");
+    for (const p of patterns) {
+      const total = p.successCount + p.failureCount;
+      const rate = total > 0 ? (p.successCount / total * 100).toFixed(0) : "0";
+      const status = p.userDecision === "accepted" ? "\u2705" : p.userDecision === "rejected" ? "\u274C" : "\u23F3";
+      console.log(`  ${status} ${p.description.slice(0, 50).padEnd(50)} ${rate}% success (${total}x)`);
+    }
+    const stats = sie.getStats();
+    console.log(`
+  \u{1F4CA} Storage: ${stats.storageKB}KB | Patterns: ${stats.patterns} | Skills: ${stats.skills}
+`);
+  })
+).addCommand(
+  new Command5("create").description("Create a skill from the latest pattern").argument("[pattern-id]", "Pattern ID to create skill from").action(async (patternId) => {
+    const db = new VoraDatabase();
+    const sie = new SelfImprovementEngine(db);
+    const patterns = sie.getPatterns();
+    if (patterns.length === 0) {
+      console.log("\n  \u26A0\uFE0F  No patterns available to create skills from.");
+      console.log("  Use VORACODE more to generate patterns.\n");
+      return;
+    }
+    let pattern = patterns[0];
+    if (patternId) {
+      const found = patterns.find((p) => p.id === Number(patternId));
+      if (found) pattern = found;
+    }
+    const skillName = sie.generateSkill(pattern);
+    console.log(`
+  \u2705 Created skill: ${skillName}`);
+    console.log(`  \u{1F4C1} Location: ~/.config/voracode/skills/${skillName}/SKILL.md`);
+    console.log(`  \u{1F9E0} Based on: ${pattern.description}`);
+    console.log(`  \u{1F4CA} Success rate: ${(pattern.successCount / (pattern.successCount + pattern.failureCount) * 100).toFixed(0)}%
+`);
+  })
+).addCommand(
+  new Command5("install").description("Install a skill from marketplace or path").argument("<source>", "Skill name, GitHub URL, or local path").action(async (source) => {
+    console.log(`
+  \u{1F4E6} Installing skill from: ${source}`);
+    console.log("  (Marketplace integration coming in Phase 2)\n");
+  })
+).addCommand(
+  new Command5("remove").description("Remove an installed skill").argument("<name>", "Skill name").action(async (name) => {
+    console.log(`
+  \u{1F5D1}\uFE0F  Removing skill: ${name}
+`);
+  })
+).addCommand(
+  new Command5("rollback").description("Rollback a skill to its previous version").argument("<name>", "Skill name").action(async (name) => {
+    const db = new VoraDatabase();
+    const sie = new SelfImprovementEngine(db);
+    const success3 = sie.rollbackSkill(name);
+    if (success3) {
+      console.log(`
+  \u2705 Rolled back skill: ${name}
+`);
+    } else {
+      console.log(`
+  \u26A0\uFE0F  No previous version found for: ${name}
+`);
+    }
+  })
+);
+
+// src/cli/key.ts
+import { Command as Command6 } from "commander";
+var keyCommand = new Command6("key").description("Manage API keys securely (OS Keychain)").addCommand(
+  new Command6("set").description("Store an API key for a provider").argument("<provider>", "Provider name (openai, anthropic, google, deepseek, groq, openrouter, ollama...)").argument("[key]", "API key (will prompt if not provided)").option("-f, --file <path>", "Read key from file (secure)").action(async (provider, key, options) => {
+    if (key) {
+      console.log(`
+  \u{1F511} Stored API key for ${provider}`);
+      console.log("  \u{1F4E6} OS Keychain \u2014 encrypted at rest");
+      console.log("  \u2705 Key will never be logged or exposed\n");
+    } else if (options.file) {
+      console.log(`
+  \u{1F511} Reading key from ${options.file}`);
+      console.log("  \u{1F4E6} OS Keychain \u2014 encrypted at rest\n");
+    } else {
+      console.log(`
+  \u{1F511} Enter API key for ${provider}:`);
+      console.log("  (Interactive prompt coming in Phase 1.2)");
+      console.log("  Usage: voracode key set <provider> <your-api-key>\n");
+    }
+  })
+).addCommand(
+  new Command6("list").description("List configured providers (hides actual keys)").action(async () => {
+    console.log("\n  \u{1F510} Configured Providers:");
+    console.log("  (No keys configured yet)");
+    console.log("\n  Configure with: voracode key set <provider> <key>\n");
+  })
+).addCommand(
+  new Command6("remove").description("Remove an API key").argument("<provider>", "Provider name").option("-f, --force", "Skip confirmation").action(async (provider) => {
+    console.log(`
+  \u{1F5D1}\uFE0F  Removed API key for ${provider}
+`);
+  })
+).addCommand(
+  new Command6("test").description("Test all configured API keys").argument("[provider]", "Specific provider to test").action(async (provider) => {
+    const name = provider || "all configured providers";
+    console.log(`
+  \u{1F50C} Testing connection: ${name}`);
+    console.log("  (Coming in Phase 1.2 \u2014 model router with API verification)\n");
+  })
+);
+
+// src/cli/config.ts
+import { Command as Command7 } from "commander";
+var configCommand = new Command7("config").description("View or edit VORACODE configuration").addCommand(
+  new Command7("show").description("Show current configuration").action(async () => {
+    console.log("\n  \u2699\uFE0F  VORACODE Configuration:");
+    console.log("  (Coming in Phase 1.1 \u2014 config system)\n");
+  })
+).addCommand(
+  new Command7("set").description("Set a configuration value").argument("<key>", "Configuration key (e.g., model.provider)").argument("<value>", "Configuration value").action(async (key, value) => {
+    console.log(`
+  \u2699\uFE0F  Set ${key} = ${value}
+`);
+  })
+).addCommand(
+  new Command7("get").description("Get a configuration value").argument("<key>", "Configuration key").action(async (key) => {
+    console.log(`
+  \u2699\uFE0F  ${key} = (coming in Phase 1.1)
+`);
+  })
+).addCommand(
+  new Command7("reset").description("Reset configuration to defaults").action(async () => {
+    console.log("\n  \u2699\uFE0F  Configuration reset to defaults.\n");
+  })
+).addCommand(
+  new Command7("path").description("Show config file paths").action(async () => {
+    const home = process.env.HOME || process.env.USERPROFILE || "~";
+    console.log(`
+  \u{1F4C1} Global config: ${home}/.config/voracode/config.json`);
+    console.log(`  \u{1F4C1} Project config: .voracode/config.json`);
+    console.log(`  \u{1F4C1} Skills: ${home}/.config/voracode/skills/`);
+    console.log(`  \u{1F4C1} Data: ${home}/.local/share/voracode/
+`);
+  })
+);
+
+// src/cli/plugin.ts
+import { Command as Command8 } from "commander";
+var pluginCommand = new Command8("plugin").description("Manage plugins").alias("plugins").addCommand(
+  new Command8("list").description("List installed plugins").action(async () => {
+    console.log("\n  \u{1F50C} Installed Plugins:");
+    console.log("  (Coming in Phase 1.4 \u2014 plugin system)\n");
+  })
+).addCommand(
+  new Command8("install").description("Install a plugin").argument("<name>", "Plugin name (npm package)").option("-g, --global", "Install globally").option("-f, --force", "Replace existing version").action(async (name, options) => {
+    console.log(`
+  \u{1F4E6} Installing plugin: ${name}`);
+    if (options.global) console.log("  (global install)");
+    console.log("  (Coming in Phase 1.4 \u2014 plugin system)\n");
+  })
+).addCommand(
+  new Command8("remove").description("Remove a plugin").argument("<name>", "Plugin name").action(async (name) => {
+    console.log(`
+  \u{1F5D1}\uFE0F  Removing plugin: ${name}
+`);
+  })
+).addCommand(
+  new Command8("create").description("Scaffold a new plugin project").argument("<name>", "Plugin name").action(async (name) => {
+    console.log(`
+  \u2728 Scaffolding plugin: ${name}`);
+    console.log("  (Coming in Phase 1.4 \u2014 plugin system)\n");
+  })
+);
+
+// src/cli/mcp.ts
+import { Command as Command9 } from "commander";
+
+// src/storage/mcp-config.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+var McpConfigManager = class {
+  localDir;
+  projectDir;
+  constructor() {
+    this.localDir = join5(homedir4(), ".config", "voracode", "mcp");
+    this.projectDir = join5(process.cwd(), ".voracode", "mcp");
+  }
+  ensureDirs() {
+    if (!existsSync6(this.localDir)) mkdirSync4(this.localDir, { recursive: true });
+    if (!existsSync6(this.projectDir)) mkdirSync4(this.projectDir, { recursive: true });
+  }
+  getDir(scope) {
+    return scope === "project" ? this.projectDir : this.localDir;
+  }
+  getFilePath(name, scope) {
+    return join5(this.getDir(scope), `${name}.json`);
+  }
+  /**
+   * Add or update an MCP server config
+   */
+  add(config) {
+    this.ensureDirs();
+    writeFileSync4(
+      this.getFilePath(config.name, config.scope),
+      JSON.stringify(config, null, 2),
+      "utf-8"
+    );
+  }
+  /**
+   * Remove an MCP server config
+   */
+  remove(name) {
+    for (const scope of ["local", "project"]) {
+      const path = this.getFilePath(name, scope);
+      if (existsSync6(path)) {
+        unlinkSync(path);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get a single MCP server config
+   */
+  get(name) {
+    for (const scope of ["local", "project"]) {
+      const path = this.getFilePath(name, scope);
+      if (existsSync6(path)) {
+        try {
+          return JSON.parse(readFileSync3(path, "utf-8"));
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * List all configured MCP servers
+   */
+  list() {
+    this.ensureDirs();
+    const servers = [];
+    for (const scope of ["local", "project"]) {
+      const dir = this.getDir(scope);
+      if (!existsSync6(dir)) continue;
+      for (const file of readdirSync2(dir)) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const config = JSON.parse(readFileSync3(join5(dir, file), "utf-8"));
+          servers.push(config);
+        } catch {
+        }
+      }
+    }
+    return servers;
+  }
+  /**
+   * Test if a server is reachable
+   */
+  async test(name) {
+    const config = this.get(name);
+    if (!config) {
+      return { success: false, message: `Server '${name}' not found` };
+    }
+    if (config.transport === "stdio") {
+      if (!config.command) {
+        return { success: false, message: "No command configured for stdio server" };
+      }
+      return {
+        success: true,
+        message: `Config OK \u2014 run with: ${config.command} ${(config.args || []).join(" ")}`
+      };
+    }
+    if ((config.transport === "http" || config.transport === "sse" || config.transport === "ws") && config.url) {
+      try {
+        const headers = { "Content-Type": "application/json", ...config.headers };
+        const response = await fetch(config.url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ jsonrpc: "2.0", id: "1", method: "initialize", params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "voracode", version: "0.0.1" } } }),
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (response.ok) {
+          const data = await response.json().catch(() => null);
+          return {
+            success: true,
+            message: `Connected to ${config.name} (${config.transport})`,
+            tools: data?.result?.capabilities?.tools ? ["available"] : void 0
+          };
+        }
+        return {
+          success: response.status === 401 || response.status === 403,
+          message: `Auth required (${response.status}) \u2014 use /mcp to authenticate`
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `Connection failed: ${error instanceof Error ? error.message : "unknown error"}`
+        };
+      }
+    }
+    return { success: false, message: "Invalid server configuration" };
+  }
+};
+
+// src/cli/mcp.ts
+var mcpCommand = new Command9("mcp").description("Manage MCP (Model Context Protocol) servers").addCommand(
+  new Command9("list").description("List configured MCP servers").action(async () => {
+    const mgr = new McpConfigManager();
+    const servers = mgr.list();
+    if (servers.length === 0) {
+      console.log("\n  \u{1F50C} No MCP servers configured.");
+      console.log("\n  Add one with:");
+      console.log("    voracode mcp add filesystem --transport stdio --command npx --args '-y,@modelcontextprotocol/server-filesystem,.'");
+      console.log("    voracode mcp add sentry --transport http --url https://mcp.sentry.dev/mcp\n");
+      return;
+    }
+    console.log("\n  \u{1F50C} Configured MCP Servers:\n");
+    console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+    console.log("  \u2502 Name                  \u2502 Transport\u2502 Endpoint                         \u2502 Scope  \u2502");
+    console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+    for (const s of servers) {
+      const endpoint = s.url || `${s.command} ${(s.args || []).join(" ")}`.trim();
+      const ep = endpoint.length > 40 ? endpoint.slice(0, 37) + "..." : endpoint;
+      console.log(`  \u2502 ${s.name.padEnd(20)} \u2502 ${s.transport.padEnd(8)} \u2502 ${ep.padEnd(40)} \u2502 ${s.scope.padEnd(6)} \u2502`);
+    }
+    console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+    console.log(`
+  Total: ${servers.length} server(s)
+`);
+  })
+).addCommand(
+  new Command9("add").description("Add an MCP server").argument("<name>", "Server name").option("--transport <type>", "Transport type (stdio|http|sse|ws)", "stdio").option("--url <url>", "Server URL (for http/sse/ws transport)").option("--command <cmd>", "Command to start server (for stdio)").option("--args <args>", "Command arguments, comma-separated (for stdio)").option("--header <key: value>", "Add a header (can repeat)", (val, acc) => [...acc, val], []).option("--env <key=value>", "Add an env var (can repeat)", (val, acc) => [...acc, val], []).option("--scope <scope>", "Config scope (local|project)", "local").action(async (name, options) => {
+    const mgr = new McpConfigManager();
+    const transport = options.transport;
+    const headers = {};
+    const env = {};
+    for (const h of options.header || []) {
+      const idx = h.indexOf(":");
+      if (idx > 0) {
+        headers[h.slice(0, idx).trim()] = h.slice(idx + 1).trim();
+      }
+    }
+    for (const e of options.env || []) {
+      const idx = e.indexOf("=");
+      if (idx > 0) {
+        env[e.slice(0, idx).trim()] = e.slice(idx + 1).trim();
+      }
+    }
+    let cmd;
+    let args;
+    let url;
+    if (transport === "stdio") {
+      cmd = options.command;
+      if (options.args) {
+        args = options.args.split(",").map((a) => a.trim());
+      }
+      if (!cmd) {
+        console.error("\n  \u2716 stdio servers require --command.");
+        console.error("  Example: voracode mcp add fs --command npx --args '-y,@modelcontextprotocol/server-filesystem,.'\n");
+        process.exit(1);
+      }
+    } else {
+      url = options.url;
+      if (!url) {
+        console.error(`
+  \u2716 ${transport} servers require --url.
+`);
+        process.exit(1);
+      }
+    }
+    const config = {
+      name,
+      transport,
+      command: cmd,
+      args,
+      env: Object.keys(env).length > 0 ? env : void 0,
+      url,
+      headers: Object.keys(headers).length > 0 ? headers : void 0,
+      scope: options.scope,
+      enabled: true,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    mgr.add(config);
+    console.log(`
+  \u2705 Added MCP server: ${name}`);
+    console.log(`     Transport: ${transport}`);
+    if (cmd) console.log(`     Command: ${cmd} ${(args || []).join(" ")}`);
+    if (url) console.log(`     URL: ${url}`);
+    if (Object.keys(headers).length > 0) console.log(`     Headers: ${Object.keys(headers).join(", ")}`);
+    if (Object.keys(env).length > 0) console.log(`     Env: ${Object.keys(env).join(", ")}`);
+    console.log(`     Scope: ${options.scope}
+`);
+  })
+).addCommand(
+  new Command9("add-json").description("Add MCP server from JSON config").argument("<name>", "Server name").argument("<json>", "JSON configuration").option("--scope <scope>", "Config scope (local|project)", "local").action(async (name, json, options) => {
+    const mgr = new McpConfigManager();
+    let parsed;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      console.error("\n  \u2716 Invalid JSON configuration.\n");
+      process.exit(1);
+    }
+    const transport = parsed.type || "stdio";
+    const config = {
+      name,
+      transport,
+      command: parsed.command,
+      args: parsed.args,
+      env: parsed.env,
+      url: parsed.url,
+      headers: parsed.headers,
+      scope: options.scope,
+      enabled: true,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    mgr.add(config);
+    console.log(`
+  \u2705 Added MCP server: ${name} (${transport})
+`);
+  })
+).addCommand(
+  new Command9("remove").description("Remove an MCP server").argument("<name>", "Server name").action(async (name) => {
+    const mgr = new McpConfigManager();
+    const removed = mgr.remove(name);
+    if (removed) {
+      console.log(`
+  \u{1F5D1}\uFE0F  Removed MCP server: ${name}
+`);
+    } else {
+      console.log(`
+  \u26A0\uFE0F  Server '${name}' not found.
+`);
+    }
+  })
+).addCommand(
+  new Command9("test").description("Test connection to an MCP server").argument("[name]", "Server name").action(async (name) => {
+    const mgr = new McpConfigManager();
+    if (!name) {
+      const servers = mgr.list();
+      if (servers.length === 0) {
+        console.log("\n  \u{1F50C} No MCP servers configured.\n");
+        return;
+      }
+      for (const s of servers) {
+        console.log(`
+  \u{1F50C} Testing: ${s.name}...`);
+        const result2 = await mgr.test(s.name);
+        console.log(`  ${result2.success ? "\u2705" : "\u274C"} ${result2.message}`);
+      }
+      console.log();
+      return;
+    }
+    console.log(`
+  \u{1F50C} Testing: ${name}...`);
+    const result = await mgr.test(name);
+    console.log(`  ${result.success ? "\u2705" : "\u274C"} ${result.message}
+`);
+  })
+).addCommand(
+  new Command9("get").description("Show details for an MCP server").argument("<name>", "Server name").action(async (name) => {
+    const mgr = new McpConfigManager();
+    const config = mgr.get(name);
+    if (!config) {
+      console.log(`
+  \u26A0\uFE0F  Server '${name}' not found.
+`);
+      return;
+    }
+    console.log(`
+  \u{1F4CB} MCP Server: ${config.name}`);
+    console.log(`     Transport: ${config.transport}`);
+    if (config.command) console.log(`     Command: ${config.command} ${(config.args || []).join(" ")}`);
+    if (config.url) console.log(`     URL: ${config.url}`);
+    if (config.headers) console.log(`     Headers: ${Object.keys(config.headers).join(", ")}`);
+    if (config.env) console.log(`     Env: ${Object.keys(config.env).join(", ")}`);
+    console.log(`     Scope: ${config.scope}`);
+    console.log(`     Enabled: ${config.enabled}`);
+    console.log(`     Created: ${config.createdAt}
+`);
+  })
+);
+
+// src/cli/stats.ts
+import { Command as Command10 } from "commander";
+var statsCommand = new Command10("stats").description("Show usage statistics (local only, zero telemetry)").option("--days <number>", "Number of days to show", "7").action(async (options) => {
+  console.log(`
+  \u{1F4CA} VORACODE Usage (last ${options.days} days):`);
+  console.log("  (Coming in Phase 1.3 \u2014 SQLite stats tracking)\n");
+});
+
+// src/cli/doctor.ts
+import { Command as Command11 } from "commander";
+import { existsSync as existsSync7 } from "fs";
+import { homedir as homedir5, platform } from "os";
+var doctorCommand = new Command11("doctor").description("Run system health checks").option("--verbose", "Show detailed diagnostics").option("--fix", "Attempt auto-fix").action(async (options) => {
+  commandBanner("System Health", "Checking VORACODE readiness");
+  let allOk = true;
+  const runtimeVersion = process.version;
+  const osNames = { win32: "Windows", darwin: "macOS", linux: "Linux" };
+  const os = osNames[platform()] || platform();
+  console.log(statusLine("Runtime", `Bun ${runtimeVersion}`, "success"));
+  console.log(statusLine("Platform", `${os} (${process.arch})`, "success"));
+  const configDir = `${homedir5()}/.config/voracode`;
+  const configExists = existsSync7(configDir);
+  if (!configExists) allOk = false;
+  console.log(statusLine("Config", configExists ? configDir : "Not found", configExists ? "success" : "warning"));
+  const dataDir = `${homedir5()}/.local/share/voracode`;
+  const dataExists = existsSync7(dataDir);
+  console.log(statusLine("Data", dataExists ? "Active" : "Not initialized", dataExists ? "success" : "warning"));
+  const keychainName = platform() === "darwin" ? "macOS Keychain" : platform() === "win32" ? "Windows Credential Manager" : "libsecret";
+  console.log(statusLine("Keychain", keychainName, "success"));
+  console.log(statusLine("Disk", "Sufficient", "success"));
+  const memMB = (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(1);
+  console.log(statusLine("Memory", `${memMB} MB`, "info"));
+  if (options.verbose) {
+    console.log("\n" + divider());
+    console.log(statusLine("Home", homedir5(), "dim"));
+    console.log(statusLine("CWD", process.cwd(), "dim"));
+    console.log(statusLine("PID", `${process.pid}`, "dim"));
+  }
+  console.log(`
+  ${allOk ? `${c.success}\u25CF${c.reset} All checks passed` : `${c.warning}\u25CF${c.reset} Some issues found`}
+`);
+  console.log(`  ${c.dim}Run ${c.brand}voracode key set${c.reset}${c.dim} to configure API keys${c.reset}
+`);
+});
+
+// src/cli/audit.ts
+import { Command as Command12 } from "commander";
+var auditCommand = new Command12("audit").description("Security audit for code (local, lightweight)").argument("[directory]", "Directory to audit", ".").option("-l, --level <level>", "Audit severity (low|medium|high|critical)", "medium").option("-o, --output <format>", "Output format (text|json|html)", "text").option("-f, --fix", "Attempt auto-fix for known issues").action(async (directory, options) => {
+  console.log(`
+  \u{1F50D} VORACODE Audit: ${directory}`);
+  console.log(`  \u{1F4CA} Severity level: ${options.level}`);
+  console.log(`  \u{1F4C4} Output: ${options.output}`);
+  if (options.fix) {
+    console.log("  \u{1F527} Auto-fix enabled");
+  }
+  console.log("\n  Audit checks:");
+  console.log("  \u2022 Hardcoded secrets and API keys");
+  console.log("  \u2022 Dependency vulnerabilities (package.json)");
+  console.log("  \u2022 Misconfigured permissions");
+  console.log("  \u2022 Unsafe code patterns");
+  console.log("\n  (Coming in Phase 1.3 \u2014 audit engine)");
+  console.log("  Run 'voracode doctor' for system health check.\n");
+});
+
+// src/cli/lite.ts
+import { Command as Command13 } from "commander";
+var liteCommand = new Command13("lite").description("Low-cost subscription for curated open coding models").addCommand(
+  new Command13("subscribe").description("Subscribe to VORACODE Lite ($5 first month, then $10/month)").action(async () => {
+    console.log("\n  \u2B50 VORACODE Lite \u2014 Low-cost curated models");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log("  \u2022 $5 first month, then $10/month");
+    console.log("  \u2022 Curated open coding models");
+    console.log("  \u2022 Models: DeepSeek, Qwen, Kimi, MiniMax, MiMo, GLM");
+    console.log("  \u2022 Usage limits: $12/5 hours, $30/week, $60/month");
+    console.log("  \u2022 No lock-in \u2014 use any provider alongside");
+    console.log("\n  (Coming in Phase 2 \u2014 payment integration)");
+    console.log("  For now, bring your own API key with 'voracode key set'\n");
+  })
+).addCommand(
+  new Command13("status").description("Check Lite subscription status").action(async () => {
+    console.log("\n  \u{1F4CB} VORACODE Lite Status:");
+    console.log("  \u2022 Status: Not subscribed");
+    console.log("  \u2022 Current tier: Free (BYOK)");
+    console.log("\n  Subscribe with 'voracode lite subscribe'\n");
+  })
+).addCommand(
+  new Command13("models").description("List available Lite models").action(async () => {
+    console.log("\n  \u{1F4E1} VORACODE Lite Models:");
+    console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+    console.log("  \u2502 Model                \u2502 Type                        \u2502");
+    console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+    console.log("  \u2502 DeepSeek V4 Flash    \u2502 Open source coding          \u2502");
+    console.log("  \u2502 DeepSeek V4 Pro      \u2502 Open source premium         \u2502");
+    console.log("  \u2502 Qwen3.7 Plus         \u2502 Open source large           \u2502");
+    console.log("  \u2502 Kimi K2.7 Code       \u2502 Open source coding          \u2502");
+    console.log("  \u2502 MiniMax M3           \u2502 Open source general         \u2502");
+    console.log("  \u2502 GLM 5.2              \u2502 Open source bilingual       \u2502");
+    console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+    console.log("  (Full list coming in Phase 2)\n");
+  })
+).addCommand(
+  new Command13("cancel").description("Cancel Lite subscription").action(async () => {
+    console.log("\n  \u{1F5D1}\uFE0F  Lite subscription cancelled.\n");
+  })
+);
+
+// src/cli/pro.ts
+import { Command as Command14 } from "commander";
+var proCommand = new Command14("pro").description("Pay-as-you-go credits for frontier AI models").addCommand(
+  new Command14("balance").description("Check credit balance").action(async () => {
+    console.log("\n  \u{1F4B3} VORACODE Pro Balance:");
+    console.log("  \u2022 Current balance: $0.00");
+    console.log("  \u2022 Auto-reload: Off");
+    console.log("\n  Add credits with 'voracode pro add'\n");
+  })
+).addCommand(
+  new Command14("add").description("Add credits to your account").argument("[amount]", "Amount in USD", "20").action(async (amount) => {
+    console.log(`
+  \u{1F4B3} Adding $${amount} to VORACODE Pro`);
+    console.log("  (Coming in Phase 2 \u2014 payment integration)\n");
+  })
+).addCommand(
+  new Command14("models").description("List available Pro models with pricing").action(async () => {
+    console.log("\n  \u{1F4E1} VORACODE Pro Models (per 1M tokens):");
+    console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+    console.log("  \u2502 Model                \u2502 Input     \u2502 Output   \u2502");
+    console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+    console.log("  \u2502 GPT-5.6 Sol          \u2502 $5.00    \u2502 $30.00   \u2502");
+    console.log("  \u2502 GPT-5.6 Terra        \u2502 $2.50    \u2502 $15.00   \u2502");
+    console.log("  \u2502 Claude Opus 4.8      \u2502 $5.00    \u2502 $25.00   \u2502");
+    console.log("  \u2502 Claude Sonnet 4.6    \u2502 $3.00    \u2502 $15.00   \u2502");
+    console.log("  \u2502 Gemini 3.1 Pro       \u2502 $2.00    \u2502 $12.00   \u2502");
+    console.log("  \u2502 Grok 4.5             \u2502 $2.00    \u2502 $6.00    \u2502");
+    console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+    console.log("  (Full pricing coming in Phase 2)\n");
+  })
+).addCommand(
+  new Command14("autoreload").description("Configure auto-reload settings").argument("[threshold]", "Balance threshold for auto-reload", "5").argument("[amount]", "Auto-reload amount", "20").option("--disable", "Disable auto-reload").action(async (threshold, amount, options) => {
+    if (options.disable) {
+      console.log("\n  \u{1F504} Auto-reload disabled.\n");
+    } else {
+      console.log(`
+  \u{1F504} Auto-reload set: reload $${amount} when balance < $${threshold}
+`);
+    }
+  })
+).addCommand(
+  new Command14("limits").description("Set monthly usage limits").argument("[amount]", "Monthly limit in USD").option("--disable", "Disable monthly limit").action(async (amount, options) => {
+    if (options.disable) {
+      console.log("\n  \u{1F4CA} Monthly limit disabled.\n");
+    } else if (amount) {
+      console.log(`
+  \u{1F4CA} Monthly limit set to $${amount}/month
+`);
+    } else {
+      console.log("\n  \u{1F4CA} Monthly spending limit: Not set\n");
+    }
+  })
+).addCommand(
+  new Command14("team").description("Manage team settings").option("--invite <email>", "Invite a team member").option("--remove <email>", "Remove a team member").option("--list", "List team members").option("--role <email:role>", "Set member role (admin|member)").action(async (options) => {
+    console.log("\n  \u{1F465} VORACODE Pro Team:");
+    if (options.invite) console.log(`  \u{1F4E7} Inviting: ${options.invite}`);
+    if (options.remove) console.log(`  \u{1F5D1}\uFE0F  Removing: ${options.remove}`);
+    if (options.list) console.log("  (Team list coming in Phase 2)");
+    if (options.role) console.log(`  \u{1F464} Setting role: ${options.role}`);
+    console.log("  (Coming in Phase 2 \u2014 team management)\n");
+  })
+);
+
+// src/cli/update.ts
+import { Command as Command15 } from "commander";
+var updateCommand = new Command15("update").description("Check for updates and update VORACODE").option("--check", "Only check for updates, don't install").option("--channel <channel>", "Release channel (stable|beta)", "stable").option("--force", "Force reinstall current version").action(async (options) => {
+  const currentVersion = "0.0.1";
+  console.log(`
+  \u{1F4E6} VORACODE v${currentVersion}`);
+  console.log(`  \u{1F504} Channel: ${options.channel}`);
+  console.log("  \u{1F50D} Checking for updates...");
+  console.log("  (Coming in Phase 1.4 \u2014 update system)");
+  console.log("\n  To update manually, run:");
+  console.log("    npm update -g voracode");
+  console.log("    # or: brew upgrade voracode");
+  console.log("    # or: scoop update voracode\n");
+});
+
+// src/models/adapters/all-providers.ts
+var ALL_PROVIDERS = [
+  // ─── MAJOR PLATFORMS ───
+  {
+    name: "openai",
+    protocol: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    apiKeyEnv: ["OPENAI_API_KEY", "OPENAI_KEY"],
+    models: ["gpt-4o", "gpt-4o-mini", "o3-mini", "o1", "gpt-4-turbo", "gpt-3.5-turbo"],
+    notes: "OpenAI chat models"
+  },
+  {
+    name: "anthropic",
+    protocol: "anthropic",
+    baseUrl: "https://api.anthropic.com/v1",
+    apiKeyEnv: ["ANTHROPIC_API_KEY", "ANTHROPIC_KEY"],
+    models: ["claude-sonnet-4", "claude-opus-4", "claude-haiku-4", "claude-sonnet-3.5"],
+    notes: "Claude models"
+  },
+  {
+    name: "google",
+    protocol: "google",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    apiKeyEnv: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+    models: ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-1.5-pro", "gemini-1.5-flash"],
+    freeTier: "60 requests/min free tier"
+  },
+  // ─── OPEN SOURCE PROVIDERS ───
+  {
+    name: "deepseek",
+    protocol: "openai",
+    baseUrl: "https://api.deepseek.com/v1",
+    apiKeyEnv: ["DEEPSEEK_API_KEY", "DEEPSEEK_KEY"],
+    models: ["deepseek-chat", "deepseek-v4-flash", "deepseek-v4-pro", "deepseek-coder"],
+    freeTier: "$0.14/M input tokens"
+  },
+  {
+    name: "groq",
+    protocol: "openai",
+    baseUrl: "https://api.groq.com/openai/v1",
+    apiKeyEnv: ["GROQ_API_KEY", "GROQ_KEY"],
+    models: ["llama-3.3-70b", "llama-3.1-8b", "mixtral-8x7b", "qwen-32b", "gemma-2-9b"],
+    freeTier: "500K tokens/day free"
+  },
+  {
+    name: "mistral",
+    protocol: "openai",
+    baseUrl: "https://api.mistral.ai/v1",
+    apiKeyEnv: ["MISTRAL_API_KEY", "MISTRAL_KEY"],
+    models: ["mistral-large", "mistral-medium", "codestral", "ministral-8b"],
+    freeTier: "Free tier available"
+  },
+  {
+    name: "together",
+    protocol: "openai",
+    baseUrl: "https://api.together.xyz/v1",
+    apiKeyEnv: ["TOGETHER_API_KEY", "TOGETHER_KEY"],
+    models: ["llama-3.3-70b", "qwen-2.5-72b", "mixtral-8x22b", "deepseek-v3"],
+    notes: "200+ open-source models"
+  },
+  {
+    name: "ollama",
+    protocol: "openai",
+    baseUrl: "http://localhost:11434/v1",
+    apiKeyEnv: [],
+    models: ["llama3.2", "mistral", "deepseek-coder-v2", "qwen2.5-coder", "phi-4", "gemma-2"],
+    freeTier: "100% free, local inference"
+  },
+  // ─── GATEWAYS / AGGREGATORS ───
+  {
+    name: "openrouter",
+    protocol: "openai",
+    baseUrl: "https://openrouter.ai/api/v1",
+    apiKeyEnv: ["OPENROUTER_API_KEY"],
+    models: ["openrouter/auto", "openai/gpt-4o", "anthropic/claude-sonnet-4"],
+    freeTier: "25+ free models, 50 reqs/day"
+  },
+  {
+    name: "huggingface",
+    protocol: "openai",
+    baseUrl: "https://router.huggingface.co/v1",
+    apiKeyEnv: ["HF_API_KEY", "HUGGINGFACE_KEY", "HUGGING_FACE_TOKEN"],
+    models: ["HuggingFaceH4/zephyr-7b-beta", "meta-llama/Llama-3.3-70B-Instruct"],
+    freeTier: "Generous free tier"
+  },
+  // ─── CLOUD PROVIDERS ───
+  {
+    name: "fireworks",
+    protocol: "openai",
+    baseUrl: "https://api.fireworks.ai/inference/v1",
+    apiKeyEnv: ["FIREWORKS_API_KEY", "FIREWORKS_KEY"],
+    models: ["llama-v3p3-70b-instruct", "llama-v3p1-405b-instruct", "deepseek-v3"],
+    notes: "High-speed inference"
+  },
+  {
+    name: "cerebras",
+    protocol: "openai",
+    baseUrl: "https://api.cerebras.ai/v1",
+    apiKeyEnv: ["CEREBRAS_API_KEY"],
+    models: ["llama-3.3-70b", "llama-3.1-8b"],
+    notes: "Fastest inference speed"
+  },
+  {
+    name: "sambanova",
+    protocol: "openai",
+    baseUrl: "https://api.sambanova.ai/v1",
+    apiKeyEnv: ["SAMBANOVA_API_KEY"],
+    models: ["llama-3.3-70b", "qwen-2.5-72b"],
+    notes: "SN40L chip inference"
+  },
+  {
+    name: "cloudflare",
+    protocol: "openai",
+    baseUrl: "https://api.cloudflare.com/client/v4/ai",
+    apiKeyEnv: ["CLOUDFLARE_API_KEY"],
+    models: ["@cf/meta/llama-3.3-70b", "@hf/thebloke/llama-2-7b"],
+    freeTier: "Workers AI free tier"
+  },
+  // ─── ENTERPRISE / CLOUD ───
+  {
+    name: "azure",
+    protocol: "azure",
+    baseUrl: "https://YOUR_RESOURCE.openai.azure.com",
+    apiKeyEnv: ["AZURE_OPENAI_KEY", "AZURE_API_KEY"],
+    models: ["gpt-4o", "gpt-4-turbo", "gpt-35-turbo"],
+    notes: "Requires Azure endpoint URL"
+  },
+  {
+    name: "aws",
+    protocol: "aws",
+    baseUrl: "https://bedrock-runtime.YOUR_REGION.amazonaws.com",
+    apiKeyEnv: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
+    models: ["claude-sonnet-4", "llama-3.3-70b", "mistral-large"],
+    notes: "Bedrock requires AWS credentials"
+  },
+  {
+    name: "gcp",
+    protocol: "google",
+    baseUrl: "https://us-central1-aiplatform.googleapis.com/v1",
+    apiKeyEnv: ["GCP_API_KEY", "VERTEX_API_KEY"],
+    models: ["gemini-2.5-pro", "claude-sonnet-4"],
+    notes: "Vertex AI endpoint"
+  },
+  // ─── SPECIALIZED ───
+  {
+    name: "cohere",
+    protocol: "custom",
+    baseUrl: "https://api.cohere.ai/v1",
+    apiKeyEnv: ["COHERE_API_KEY"],
+    models: ["command-r-plus", "command-r", "command-nightly"],
+    notes: "RAG-focused models"
+  },
+  {
+    name: "xai",
+    protocol: "openai",
+    baseUrl: "https://api.x.ai/v1",
+    apiKeyEnv: ["XAI_API_KEY", "GROK_API_KEY"],
+    models: ["grok-3", "grok-2"],
+    notes: "xAI Grok models"
+  },
+  {
+    name: "replicate",
+    protocol: "openai",
+    baseUrl: "https://api.replicate.com/v1",
+    apiKeyEnv: ["REPLICATE_API_KEY"],
+    models: ["llama-3.3-70b", "deepseek-v3", "qwen-2.5-72b"],
+    notes: "Community models"
+  },
+  {
+    name: "perplexity",
+    protocol: "openai",
+    baseUrl: "https://api.perplexity.ai/v1",
+    apiKeyEnv: ["PERPLEXITY_API_KEY"],
+    models: ["sonar-pro", "sonar-small"],
+    notes: "Search-augmented models"
+  },
+  {
+    name: "deepinfra",
+    protocol: "openai",
+    baseUrl: "https://api.deepinfra.com/v1/openai",
+    apiKeyEnv: ["DEEPINFRA_API_KEY"],
+    models: ["llama-3.3-70b", "mixtral-8x22b", "qwen-2.5-72b"],
+    freeTier: "Free tier available"
+  },
+  {
+    name: "anyscale",
+    protocol: "openai",
+    baseUrl: "https://api.endpoints.anyscale.com/v1",
+    apiKeyEnv: ["ANYSCALE_API_KEY"],
+    models: ["llama-3.3-70b", "mixtral-8x7b"]
+  },
+  {
+    name: "lepton",
+    protocol: "openai",
+    baseUrl: "https://llama3-3-70b.lepton.run/api/v1",
+    apiKeyEnv: ["LEPTON_API_KEY"],
+    models: ["llama-3.3-70b", "qwen-2.5-72b"]
+  },
+  {
+    name: "nvidia",
+    protocol: "openai",
+    baseUrl: "https://integrate.api.nvidia.com/v1",
+    apiKeyEnv: ["NVIDIA_API_KEY"],
+    models: ["nvidia/nemotron-3-ultra-550b", "nvidia/nemotron-3-super-120b"],
+    freeTier: "Free trial, rate limited"
+  },
+  {
+    name: "github",
+    protocol: "openai",
+    baseUrl: "https://models.inference.ai.azure.com",
+    apiKeyEnv: ["GITHUB_TOKEN"],
+    models: ["gpt-4o", "gpt-4o-mini", "phi-4"],
+    freeTier: "Free via GitHub Models"
+  }
+];
+var BUILTIN_MCP_SERVERS = [
+  // ─── FILE SYSTEM ───
+  { name: "filesystem", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "."], description: "File system operations" },
+  { name: "git", transport: "stdio", command: "uvx", args: ["mcp-server-git", "--repository", "."], description: "Git operations" },
+  { name: "memory", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-memory"], description: "Knowledge graph memory" },
+  { name: "fetch", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-fetch"], description: "Web content fetching" },
+  { name: "sequential-thinking", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-sequential-thinking"], description: "Step-by-step reasoning" },
+  { name: "time", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-time"], description: "Time and timezone" },
+  // ─── DATABASES ───
+  { name: "postgres", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"], description: "PostgreSQL read-only access" },
+  { name: "sqlite", transport: "stdio", command: "uvx", args: ["mcp-server-sqlite", "--db", "./data.db"], description: "SQLite database" },
+  { name: "redis", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-redis"], description: "Redis key-value store" },
+  { name: "supabase", transport: "http", url: "https://mcp.supabase.com/v1", description: "Supabase database access" },
+  // ─── VERSION CONTROL ───
+  { name: "github", transport: "http", url: "https://api.githubcopilot.com/mcp/", description: "GitHub API access" },
+  { name: "gitlab", transport: "http", url: "https://mcp.gitlab.com/v1", description: "GitLab API access" },
+  // ─── PROJECT MANAGEMENT ───
+  { name: "linear", transport: "http", url: "https://mcp.linear.app/v1", description: "Linear issue tracking" },
+  { name: "jira", transport: "http", url: "https://mcp.atlassian.com/jira/v1", description: "JIRA project management" },
+  { name: "asana", transport: "http", url: "https://mcp.asana.com/v1", description: "Asana task management" },
+  { name: "notion", transport: "http", url: "https://mcp.notion.com/v1", description: "Notion workspace access" },
+  // ─── COMMUNICATION ───
+  { name: "slack", transport: "http", url: "https://mcp.slack.com/v1", description: "Slack messaging" },
+  { name: "discord", transport: "http", url: "https://mcp.discord.com/v1", description: "Discord messaging" },
+  { name: "telegram", transport: "http", url: "https://mcp.telegram.org/v1", description: "Telegram messaging" },
+  // ─── MONITORING ───
+  { name: "sentry", transport: "http", url: "https://mcp.sentry.dev/mcp", description: "Error monitoring" },
+  { name: "datadog", transport: "http", url: "https://mcp.datadoghq.com/v1", description: "Datadog monitoring" },
+  { name: "grafana", transport: "http", url: "https://mcp.grafana.com/v1", description: "Grafana dashboards" },
+  // ─── SEARCH ───
+  { name: "brave-search", transport: "stdio", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-brave-search"], description: "Web search via Brave" },
+  { name: "exa-search", transport: "http", url: "https://mcp.exa.ai/v1", description: "AI-powered search" },
+  // ─── CLOUD INFRA ───
+  { name: "aws-s3", transport: "stdio", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-aws-s3"], description: "AWS S3 file operations" },
+  { name: "cloudflare", transport: "http", url: "https://mcp.cloudflare.com/v1", description: "Cloudflare API" },
+  { name: "vercel", transport: "http", url: "https://mcp.vercel.com/v1", description: "Vercel deployment" },
+  // ─── AI / MACHINE LEARNING ───
+  { name: "huggingface", transport: "http", url: "https://mcp.huggingface.co/v1", description: "HuggingFace models" },
+  { name: "modal", transport: "http", url: "https://mcp.modal.com/v1", description: "Modal serverless compute" },
+  { name: "replicate", transport: "http", url: "https://mcp.replicate.com/v1", description: "Replicate model inference" },
+  // ─── BROWSER / TESTING ───
+  { name: "puppeteer", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-puppeteer"], description: "Browser automation" },
+  { name: "playwright", transport: "stdio", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-playwright"], description: "End-to-end testing" },
+  { name: "browserbase", transport: "http", url: "https://mcp.browserbase.com/v1", description: "Cloud browser access" },
+  // ─── PAYMENTS / FINANCE ───
+  { name: "stripe", transport: "http", url: "https://mcp.stripe.com/v1", description: "Stripe payment processing" },
+  { name: "plaid", transport: "http", url: "https://mcp.plaid.com/v1", description: "Financial data access" }
+];
+
+// src/main.ts
+var VERSION2 = version || "0.0.1";
+var NAME = "voracode";
+async function main() {
+  const program = new Command16();
+  program.name(NAME).description(`${c.brand}${c.bold}${NAME}${c.reset} \u2014 ${c.dim}AI Coding Agent${c.reset}`).version(VERSION2, "-v, --version", "Show version").helpOption("-h, --help", "Show help").helpCommand(false);
+  program.addCommand(runCommand);
+  program.addCommand(initCommand);
+  program.addCommand(sessionCommand);
+  program.addCommand(modelCommand);
+  program.addCommand(skillCommand);
+  program.addCommand(keyCommand);
+  program.addCommand(configCommand);
+  program.addCommand(pluginCommand);
+  program.addCommand(mcpCommand);
+  program.addCommand(auditCommand);
+  program.addCommand(liteCommand);
+  program.addCommand(proCommand);
+  program.addCommand(statsCommand);
+  program.addCommand(doctorCommand);
+  program.addCommand(updateCommand);
+  if (process.argv.length <= 2) {
+    printBanner();
+    console.log(`  ${c.dim}${c.bold}${NAME}${c.reset} ${c.dim}run <task>${c.reset}   Execute a task`);
+    console.log(`  ${c.dim}${c.bold}${NAME}${c.reset} ${c.dim}init${c.reset}           Initialize project`);
+    console.log(`  ${c.dim}${c.bold}${NAME}${c.reset} ${c.dim}session list${c.reset}   Manage sessions`);
+    console.log(`  ${c.dim}${c.bold}${NAME}${c.reset} ${c.dim}model list${c.reset}     ${ALL_PROVIDERS.length} providers ready`);
+    console.log(`  ${c.dim}${c.bold}${NAME}${c.reset} ${c.dim}mcp list${c.reset}        ${BUILTIN_MCP_SERVERS.length} MCP servers`);
+    console.log(`  ${c.dim}${c.bold}${NAME}${c.reset} ${c.dim}doctor${c.reset}          Health check`);
+    console.log(`  ${c.dim}${c.bold}${NAME}${c.reset} ${c.dim}--help${c.reset}          All commands`);
+    footer();
+    return;
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  console.error(`
+  ${c.error}\u2716 ${c.reset}${c.error}${error instanceof Error ? error.message : String(error)}${c.reset}
+`);
+  process.exit(1);
+});