voracode 0.0.1

package/src/cli/model.ts

@@ -0,0 +1,103 @@
+/**
+ * voracode model — Manage AI providers and models
+ *
+ * Universal adapter system. BYOK only — no free managed models.
+ */
+
+import { Command } from "commander";
+import { ModelRouter } from "../models/router";
+
+export const modelCommand = new Command("model")
+  .description("Manage AI providers and models")
+  .addCommand(
+    new Command("list")
+      .description("List available providers and models")
+      .option("-p, --provider <name>", "Filter by provider")
+      .action(async (options) => {
+        const router = new ModelRouter();
+
+        console.log("\n  📡 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 ? "✅ configured" : "❌ not configured"}`);
+          console.log(`  Models:`);
+          for (const m of models) {
+            console.log(`    • ${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("  ┌──────────────────────┬─────────────────────────────────────────────┐");
+        console.log("  │ Protocol             │ Providers                                    │");
+        console.log("  ├──────────────────────┼─────────────────────────────────────────────┤");
+        for (const p of providers) {
+          console.log(`  │ ${p.name.padEnd(20)} │ ${p.protocols.padEnd(43)} │`);
+        }
+        console.log("  └──────────────────────┴─────────────────────────────────────────────┘");
+
+        console.log("\n  🔑 Key Status:");
+        for (const name of ["openai", "anthropic", "deepseek", "groq", "google", "openrouter"]) {
+          const status = router.hasValidKey(name) ? "✅" : "❌";
+          console.log(`  ${status} ${name}`);
+        }
+
+        console.log("\n  ⚠️  VORACODE is BYOK — no free managed models.");
+        console.log("  Configure: voracode key set <provider> <key>");
+        console.log("  Or set env: PROVIDER_API_KEY=sk-...\n");
+      }),
+  )
+  .addCommand(
+    new Command("set")
+      .description("Set active model for session")
+      .argument("<model>", "Model identifier (provider/model-name)")
+      .action(async (model) => {
+        if (!model.includes("/")) {
+          console.error("\n  ✖ Use format: provider/model-name");
+          console.error("  Example: voracode model set deepseek/deepseek-chat\n");
+          process.exit(1);
+        }
+        console.log(`\n  ✅ Active model set to: ${model}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("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(`\n  ❌ No API key for '${name}'`);
+          console.log(`  Configure: voracode key set ${name} <key>\n`);
+          return;
+        }
+
+        console.log(`\n  🔌 Testing: ${name}...`);
+
+        try {
+          const result = await router.chat(`${name}/test`, [
+            { role: "user", content: "Say 'ok' if you receive this." },
+          ], { maxTokens: 10 });
+          console.log(`  ✅ Connection successful!`);
+          console.log(`  Response: ${result.content.slice(0, 100)}`);
+          console.log(`  Model: ${result.model}`);
+          console.log(`  Tokens: ${result.usage.totalTokens}\n`);
+        } catch (error) {
+          console.log(`  ❌ Connection failed:`);
+          console.log(`  ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+      }),
+  );

package/src/cli/plugin.ts

@@ -0,0 +1,49 @@
+/**
+ * voracode plugin — Manage plugins
+ *
+ * Plugins extend VORACODE with custom tools, event hooks,
+ * and integrations. Published as voracode-plugin-* npm packages.
+ */
+
+import { Command } from "commander";
+
+export const pluginCommand = new Command("plugin")
+  .description("Manage plugins")
+  .alias("plugins")
+  .addCommand(
+    new Command("list")
+      .description("List installed plugins")
+      .action(async () => {
+        console.log("\n  🔌 Installed Plugins:");
+        console.log("  (Coming in Phase 1.4 — plugin system)\n");
+      }),
+  )
+  .addCommand(
+    new Command("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(`\n  📦 Installing plugin: ${name}`);
+        if (options.global) console.log("  (global install)");
+        console.log("  (Coming in Phase 1.4 — plugin system)\n");
+      }),
+  )
+  .addCommand(
+    new Command("remove")
+      .description("Remove a plugin")
+      .argument("<name>", "Plugin name")
+      .action(async (name) => {
+        console.log(`\n  🗑️  Removing plugin: ${name}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("create")
+      .description("Scaffold a new plugin project")
+      .argument("<name>", "Plugin name")
+      .action(async (name) => {
+        console.log(`\n  ✨ Scaffolding plugin: ${name}`);
+        console.log("  (Coming in Phase 1.4 — plugin system)\n");
+      }),
+  );

package/src/cli/pro.ts

@@ -0,0 +1,97 @@
+/**
+ * voracode pro — Pay-as-you-go credits for frontier models
+ *
+ * Like OpenCode Zen: credits-based, pay per token.
+ * Access to frontier models (GPT, Claude, Gemini) plus
+ * team management, auto-reload, monthly limits.
+ *
+ * USERS MUST BRING THEIR OWN API KEY FOR FREE TIER.
+ * Pro is OPTIONAL — for users who want managed access to frontier models.
+ */
+
+import { Command } from "commander";
+
+export const proCommand = new Command("pro")
+  .description("Pay-as-you-go credits for frontier AI models")
+  .addCommand(
+    new Command("balance")
+      .description("Check credit balance")
+      .action(async () => {
+        console.log("\n  💳 VORACODE Pro Balance:");
+        console.log("  • Current balance: $0.00");
+        console.log("  • Auto-reload: Off");
+        console.log("\n  Add credits with 'voracode pro add'\n");
+      }),
+  )
+  .addCommand(
+    new Command("add")
+      .description("Add credits to your account")
+      .argument("[amount]", "Amount in USD", "20")
+      .action(async (amount) => {
+        console.log(`\n  💳 Adding $${amount} to VORACODE Pro`);
+        console.log("  (Coming in Phase 2 — payment integration)\n");
+      }),
+  )
+  .addCommand(
+    new Command("models")
+      .description("List available Pro models with pricing")
+      .action(async () => {
+        console.log("\n  📡 VORACODE Pro Models (per 1M tokens):");
+        console.log("  ┌──────────────────────┬──────────┬──────────┐");
+        console.log("  │ Model                │ Input     │ Output   │");
+        console.log("  ├──────────────────────┼──────────┼──────────┤");
+        console.log("  │ GPT-5.6 Sol          │ $5.00    │ $30.00   │");
+        console.log("  │ GPT-5.6 Terra        │ $2.50    │ $15.00   │");
+        console.log("  │ Claude Opus 4.8      │ $5.00    │ $25.00   │");
+        console.log("  │ Claude Sonnet 4.6    │ $3.00    │ $15.00   │");
+        console.log("  │ Gemini 3.1 Pro       │ $2.00    │ $12.00   │");
+        console.log("  │ Grok 4.5             │ $2.00    │ $6.00    │");
+        console.log("  └──────────────────────┴──────────┴──────────┘");
+        console.log("  (Full pricing coming in Phase 2)\n");
+      }),
+  )
+  .addCommand(
+    new Command("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  🔄 Auto-reload disabled.\n");
+        } else {
+          console.log(`\n  🔄 Auto-reload set: reload $${amount} when balance < $${threshold}\n`);
+        }
+      }),
+  )
+  .addCommand(
+    new Command("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  📊 Monthly limit disabled.\n");
+        } else if (amount) {
+          console.log(`\n  📊 Monthly limit set to $${amount}/month\n`);
+        } else {
+          console.log("\n  📊 Monthly spending limit: Not set\n");
+        }
+      }),
+  )
+  .addCommand(
+    new Command("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  👥 VORACODE Pro Team:");
+        if (options.invite) console.log(`  📧 Inviting: ${options.invite}`);
+        if (options.remove) console.log(`  🗑️  Removing: ${options.remove}`);
+        if (options.list) console.log("  (Team list coming in Phase 2)");
+        if (options.role) console.log(`  👤 Setting role: ${options.role}`);
+        console.log("  (Coming in Phase 2 — team management)\n");
+      }),
+  );

package/src/cli/run.ts

@@ -0,0 +1,101 @@
+/**
+ * voracode run — Execute a task with AI
+ *
+ * Premium execution experience with Apple-style output.
+ */
+
+import { Command } from "commander";
+import { SessionManager } from "../session/manager";
+import { ModelRouter } from "../models/router";
+import { VoraDatabase } from "../storage/database";
+import { c, spinner, success, error as err, footer } from "../ui/theme";
+
+export const 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(`\n  ${c.error}✖ Please provide a task description.${c.reset}\n`);
+      console.error(`  ${c.dim}Usage: ${c.brand}${c.bold}voracode${c.reset}${c.dim} run "your task here"${c.reset}\n`);
+      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(`\n  ${c.warning}◆${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}\n`);
+      process.exit(1);
+    }
+
+    let sessionId: string;
+    if (options.session) {
+      const existing = sessions.getSession(options.session);
+      if (!existing) {
+        console.error(`\n  ${c.error}✖ Session not found: ${options.session}${c.reset}\n`);
+        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(`\n  ${c.brand}◆${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)}...\n`);
+      if (options["dry-run"]) {
+        console.log(`  ${c.warning}◆${c.reset}  ${c.dim}Dry-run mode — no execution${c.reset}\n`);
+      }
+    }
+
+    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 · ${result.steps} steps · ${result.tokensUsed} tokens${c.reset}\n`);
+
+          // Render the AI response beautifully
+          console.log(result.content);
+
+          if (result.patternSuggestion) {
+            console.log(`\n  ${c.cyan}◆${c.reset}  ${c.dim}VORACODE noticed a pattern — run ${c.bold}voracode skill patterns${c.reset}${c.dim} to see${c.reset}`);
+          }
+
+          console.log(`\n  ${c.dim}Session: ${c.brand}${sessionId.slice(0, 8)}${c.reset}`);
+          console.log(`  ${c.dim}Data: ${sessions.getDbPath()}${c.reset}\n`);
+        } else {
+          console.log(`\n  ${c.error}✖ ${result.error || "Task failed"}${c.reset}\n`);
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      console.error(`\n  ${c.error}✖ ${error instanceof Error ? error.message : String(error)}${c.reset}\n`);
+      process.exit(1);
+    }
+
+    footer();
+  });

package/src/cli/session.ts

@@ -0,0 +1,138 @@
+/**
+ * voracode session — Manage AI agent sessions
+ */
+
+import { Command } from "commander";
+import { SessionManager } from "../session/manager";
+
+// Shared manager instance
+const getManager = () => new SessionManager();
+
+export const sessionCommand = new Command("session")
+  .description("Manage AI agent sessions")
+  .addCommand(
+    new Command("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  📋 No sessions yet. Run 'voracode run' to create one.\n");
+          return;
+        }
+
+        console.log(`\n  📋 Recent sessions (last ${options.limit}):\n`);
+        for (const s of list) {
+          const date = new Date(s.createdAt + "Z").toLocaleString();
+          console.log(`  🆔 ${s.id.slice(0, 8)}... | ${s.title.slice(0, 40).padEnd(40)} | ${s.status.padEnd(10)} | ${date}`);
+        }
+        console.log(`\n  Total: ${list.length} session(s)\n`);
+      }),
+  )
+  .addCommand(
+    new Command("show")
+      .description("Show session details")
+      .argument("<id>", "Session ID")
+      .action(async (id) => {
+        const sessions = getManager();
+        const session = sessions.getSession(id);
+
+        if (!session) {
+          console.error(`\n  ✖ Session not found: ${id}\n`);
+          process.exit(1);
+        }
+
+        console.log(`\n  📄 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}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("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(`\n  ✖ Session not found: ${id}\n`);
+          process.exit(1);
+        }
+
+        if (options.fork) {
+          const newId = sessions.fork(id);
+          if (newId) {
+            console.log(`\n  🌿 Forked session ${id.slice(0, 8)}... → ${newId.slice(0, 8)}...`);
+            console.log(`  Run: voracode run "your task" --session ${newId}\n`);
+          }
+        } else {
+          console.log(`\n  🔄 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}\n`);
+        }
+      }),
+  )
+  .addCommand(
+    new Command("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(`\n  ✖ Session not found: ${id}\n`);
+          process.exit(1);
+        }
+
+        sessions.delete(id);
+        console.log(`\n  🗑️  Session ${id.slice(0, 8)}... deleted.\n`);
+      }),
+  )
+  .addCommand(
+    new Command("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(`\n  ✖ Session not found: ${id}\n`);
+          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(`\n  💾 Session exported to ${file}\n`);
+        } else {
+          console.log(data);
+        }
+      }),
+  )
+  .addCommand(
+    new Command("import")
+      .description("Import session from JSON")
+      .argument("<file>", "JSON file path or URL")
+      .action(async (file) => {
+        console.log(`\n  📥 Importing session from ${file}\n`);
+        // TODO: implement import
+      }),
+  );

package/src/cli/skill.ts

@@ -0,0 +1,156 @@
+/**
+ * voracode skill — Manage skills
+ *
+ * Skills are reusable prompt templates that tell the agent how to handle
+ * specific tasks. Built-in skills + auto-learned skills from self-improvement.
+ */
+
+import { Command } from "commander";
+import { SelfImprovementEngine } from "../skills/self-improve/engine";
+import { VoraDatabase } from "../storage/database";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export const skillCommand = new Command("skill")
+  .description("Manage skills")
+  .alias("skills")
+  .addCommand(
+    new Command("list")
+      .description("List available skills")
+      .action(async () => {
+        const skillsDir = join(homedir(), ".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" },
+        ];
+
+        // Find learned skills
+        const learnedSkills: Array<{ name: string; description: string; source: string }> = [];
+        if (existsSync(skillsDir)) {
+          for (const dir of readdirSync(skillsDir)) {
+            const skillPath = join(skillsDir, dir, "SKILL.md");
+            if (existsSync(skillPath)) {
+              try {
+                const content = readFileSync(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  🛠️  Available Skills:\n");
+
+        if (builtinSkills.length > 0) {
+          console.log("  Built-in:");
+          for (const s of builtinSkills) {
+            console.log(`    📦 ${s.name.padEnd(20)} ${s.description}`);
+          }
+        }
+
+        if (learnedSkills.length > 0) {
+          console.log("\n  Learned (auto-generated):");
+          for (const s of learnedSkills) {
+            console.log(`    🧠 ${s.name.padEnd(20)} ${s.description}`);
+          }
+        }
+
+        console.log(`\n  Total: ${builtinSkills.length + learnedSkills.length} skills\n`);
+      }),
+  )
+  .addCommand(
+    new Command("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  🧠 No patterns detected yet.");
+          console.log("  Use VORACODE regularly — it will learn from your tasks.\n");
+          return;
+        }
+
+        console.log("\n  🧠 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" ? "✅" : p.userDecision === "rejected" ? "❌" : "⏳";
+          console.log(`  ${status} ${p.description.slice(0, 50).padEnd(50)} ${rate}% success (${total}x)`);
+        }
+
+        const stats = sie.getStats();
+        console.log(`\n  📊 Storage: ${stats.storageKB}KB | Patterns: ${stats.patterns} | Skills: ${stats.skills}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("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  ⚠️  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(`\n  ✅ Created skill: ${skillName}`);
+        console.log(`  📁 Location: ~/.config/voracode/skills/${skillName}/SKILL.md`);
+        console.log(`  🧠 Based on: ${pattern.description}`);
+        console.log(`  📊 Success rate: ${((pattern.successCount / (pattern.successCount + pattern.failureCount)) * 100).toFixed(0)}%\n`);
+      }),
+  )
+  .addCommand(
+    new Command("install")
+      .description("Install a skill from marketplace or path")
+      .argument("<source>", "Skill name, GitHub URL, or local path")
+      .action(async (source) => {
+        console.log(`\n  📦 Installing skill from: ${source}`);
+        console.log("  (Marketplace integration coming in Phase 2)\n");
+      }),
+  )
+  .addCommand(
+    new Command("remove")
+      .description("Remove an installed skill")
+      .argument("<name>", "Skill name")
+      .action(async (name) => {
+        console.log(`\n  🗑️  Removing skill: ${name}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("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 success = sie.rollbackSkill(name);
+        if (success) {
+          console.log(`\n  ✅ Rolled back skill: ${name}\n`);
+        } else {
+          console.log(`\n  ⚠️  No previous version found for: ${name}\n`);
+        }
+      }),
+  );

package/src/cli/stats.ts

@@ -0,0 +1,16 @@
+/**
+ * voracode stats — Usage statistics and analytics
+ *
+ * All stats are LOCAL by default. No data sent anywhere.
+ * User must explicitly opt-in to share anonymized usage.
+ */
+
+import { Command } from "commander";
+
+export const statsCommand = new Command("stats")
+  .description("Show usage statistics (local only, zero telemetry)")
+  .option("--days <number>", "Number of days to show", "7")
+  .action(async (options) => {
+    console.log(`\n  📊 VORACODE Usage (last ${options.days} days):`);
+    console.log("  (Coming in Phase 1.3 — SQLite stats tracking)\n");
+  });