voracode 0.0.1

package/src/cli/update.ts

@@ -0,0 +1,28 @@
+/**
+ * voracode update — Self-update command
+ *
+ * Checks for new versions on GitHub and applies updates.
+ */
+
+import { Command } from "commander";
+
+export const updateCommand = new Command("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"; // from package.json
+
+    console.log(`\n  📦 VORACODE v${currentVersion}`);
+    console.log(`  🔄 Channel: ${options.channel}`);
+    console.log("  🔍 Checking for updates...");
+
+    // TODO: Implement actual GitHub release check
+    console.log("  (Coming in Phase 1.4 — 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");
+  });

package/src/engine/agent.ts

@@ -0,0 +1,256 @@
+/**
+ * VORACODE Agent — Tool-calling agent loop
+ *
+ * The core intelligence: model suggests tool calls → tools execute →
+ * results fed back → model continues → repeat until done.
+ *
+ * Uses OpenAI function calling to give the model real tool access.
+ */
+
+import { ModelRouter, type ChatMessage, type ChatOptions } from "../models/router";
+import { VoraDatabase } from "../storage/database";
+import { ToolExecutor } from "../tools/executor";
+import { SelfImprovementEngine } from "../skills/self-improve/engine";
+
+export interface AgentResult {
+  success: boolean;
+  content: string;
+  sessionId: string;
+  tokensUsed: number;
+  turns: number;
+  steps: number;
+  error?: string;
+  patternSuggestion?: string;
+}
+
+export class Agent {
+  private router: ModelRouter;
+  private db: VoraDatabase;
+  private tools: ToolExecutor;
+  private sie: SelfImprovementEngine;
+  private systemPrompt: string;
+
+  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();
+  }
+
+  private buildSystemPrompt(): string {
+    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 — USE the tools.
+
+When the task is complete, summarize what was done.`;
+  }
+
+  /**
+   * Run the agent loop with full tool-calling
+   */
+  async runTurn(sessionId: string, userMessage: string, modelRef: string, options?: { maxTurns?: number }): Promise<AgentResult> {
+    const startTime = Date.now();
+    const maxTurns = options?.maxTurns || 15;
+    let totalTokens = 0;
+    let turns = 0;
+    let steps = 0;
+    let toolOnlyTurns = 0;  // Detection: model only using tools, never summarizing
+
+    // Get tool schemas to send with each API call
+    const toolSchemas = this.tools.getToolSchemas();
+
+    // Build message history
+    const messages: ChatMessage[] = [
+      { role: "system", content: this.systemPrompt },
+      { role: "user", content: userMessage },
+    ];
+
+    // Store the initial user message
+    this.db.addMessage(sessionId, "user", userMessage);
+
+    const toolsUsed: string[] = [];
+    const filesChanged: string[] = [];
+    const commandsRun: string[] = [];
+
+    try {
+      while (turns < maxTurns) {
+        turns++;
+
+        const chatOptions: ChatOptions = {
+          model: modelRef,
+          maxTokens: 2048,
+          temperature: 0.3,
+          tools: toolSchemas,
+          toolChoice: "auto",
+        };
+
+        // Call the model
+        const response = await this.router.chat(modelRef, messages, chatOptions);
+        totalTokens += response.usage.totalTokens;
+        this.db.recordApiCall(response.usage.inputTokens, response.usage.outputTokens);
+
+        // Store assistant response
+        if (response.content) {
+          this.db.addMessage(sessionId, "assistant", response.content, response.usage.totalTokens);
+        }
+
+        // CASE 1: Model wants to use tools
+        if (response.toolCalls && response.toolCalls.length > 0) {
+          // If model keeps using tools without responding, detect infinite loop
+          toolOnlyTurns++;
+          if (toolOnlyTurns > 10) {
+            return {
+              success: true,
+              content: "Task reached maximum tool iterations. Results so far are applied.",
+              sessionId,
+              tokensUsed: totalTokens,
+              turns,
+              steps,
+            };
+          }
+          // Add the assistant message with tool_calls to history
+          messages.push({
+            role: "assistant",
+            content: response.content || "",
+            tool_calls: response.toolCalls,
+          });
+
+          // Track tools used for self-improvement
+
+          // Execute each tool call
+          for (const toolCall of response.toolCalls) {
+            steps++;
+            toolsUsed.push(toolCall.function.name);
+
+            // Track file changes and commands for self-improvement
+            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: unknown;
+            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);
+
+            // Truncate very long results
+            const truncated = resultStr.length > 5000 ? resultStr.slice(0, 5000) + "\n... (truncated)" : resultStr;
+
+            // Audit log
+            this.db.logAudit(
+              error ? "tool_error" : "tool_execute",
+              JSON.stringify({ tool: toolCall.function.name }),
+              !error,
+            );
+
+            // Add tool result to conversation history
+            messages.push({
+              role: "tool",
+              content: truncated,
+              tool_call_id: toolCall.id,
+            });
+          }
+
+          // Continue the loop — model will see tool results and decide next step
+          continue;
+        }
+
+        // CASE 2: Model responded with text (no tool calls) — task is complete
+        this.db.updateSession(sessionId, {
+          total_tokens: totalTokens,
+          total_turns: turns,
+          status: "completed",
+        });
+
+        // Self-improvement: record task pattern and check for suggestions
+        let patternSuggestion: string | undefined;
+        if (toolsUsed.length > 0) {
+          const pattern = this.sie.recordTask(
+            userMessage,
+            toolsUsed,
+            filesChanged,
+            commandsRun,
+            true, // success
+          );
+
+          if (pattern) {
+            patternSuggestion = `\n\n💡 VORACODE noticed you've done this ${pattern.successCount + 1} times with ${(pattern.successCount / (pattern.successCount + pattern.failureCount) * 100).toFixed(0)}% success.\n   Would you like me to create a reusable skill for this?\n   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,
+        };
+      }
+
+      // MAX TURNS REACHED
+      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,
+      };
+    }
+  }
+}

package/src/engine/sub-agent.ts

@@ -0,0 +1,122 @@
+/**
+ * VORACODE Sub-Agent System — Parallel task execution agents
+ *
+ * Like Claude Code's sub-agents, Cursor's parallel agents:
+ * - Each sub-agent gets its own context window
+ * - Runs independently with specific tools
+ * - Reports back to main agent
+ * - Can use different models per task
+ */
+
+import { ModelRouter, type ChatMessage } from "../models/router";
+import { ToolExecutor } from "../tools/executor";
+import { VoraDatabase } from "../storage/database";
+
+export interface SubAgentTask {
+  id: string;
+  description: string;
+  modelRef?: string;
+  tools?: string[];
+  context?: string;
+  maxTurns?: number;
+}
+
+export interface SubAgentResult {
+  id: string;
+  success: boolean;
+  content: string;
+  tokensUsed: number;
+  turns: number;
+  error?: string;
+}
+
+export class SubAgentManager {
+  private router: ModelRouter;
+  private tools: ToolExecutor;
+  private db: VoraDatabase;
+
+  constructor() {
+    this.router = new ModelRouter();
+    this.db = new VoraDatabase();
+    this.tools = new ToolExecutor(this.db);
+  }
+
+  /**
+   * Run multiple sub-agents in parallel
+   */
+  async runParallel(tasks: SubAgentTask[], mainModel = "deepseek/deepseek-chat"): Promise<SubAgentResult[]> {
+    const results: SubAgentResult[] = [];
+    const BATCH_SIZE = 3; // Max 3 parallel agents
+
+    for (let i = 0; i < tasks.length; i += BATCH_SIZE) {
+      const batch = tasks.slice(i, i + BATCH_SIZE);
+      const batchResults = await Promise.all(
+        batch.map((task) => this.runSingle(task, mainModel)),
+      );
+      results.push(...batchResults);
+    }
+
+    return results;
+  }
+
+  /**
+   * Run a single sub-agent
+   */
+  async runSingle(task: SubAgentTask, defaultModel: string): Promise<SubAgentResult> {
+    const modelRef = task.modelRef || defaultModel;
+    const maxTurns = task.maxTurns || 5;
+    let turns = 0;
+    let totalTokens = 0;
+
+    const systemPrompt = `You are a VORACODE sub-agent handling a specific task.
+Your task: ${task.description}
+
+You have access to tools: ${(task.tools || ["file_read", "file_write", "bash", "think"]).join(", ")}
+
+Focus ONLY on your assigned task. Report back concisely.`;
+
+    const messages: ChatMessage[] = [
+      { role: "system", content: systemPrompt },
+      ...(task.context ? [{ role: "user" as const, content: task.context }] : []),
+      { role: "user" as const, content: `Execute this task: ${task.description}` },
+    ];
+
+    try {
+      while (turns < maxTurns) {
+        turns++;
+        const response = await this.router.chat(modelRef, messages, {
+          model: modelRef,
+          maxTokens: 1024,
+          temperature: 0.3,
+          tools: this.getToolSchemas(task.tools),
+          toolChoice: "auto" as const,
+        });
+
+        totalTokens += response.usage.totalTokens;
+
+        if (response.toolCalls && response.toolCalls.length > 0) {
+          messages.push({ role: "assistant", content: response.content || "", tool_calls: response.toolCalls });
+
+          for (const tc of response.toolCalls) {
+            const result = await this.tools.execute(tc.function.name, tc.function.arguments);
+            const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+            messages.push({ role: "tool", content: resultStr.slice(0, 3000), tool_call_id: tc.id });
+          }
+          continue;
+        }
+
+        return { id: task.id, success: true, content: response.content, tokensUsed: totalTokens, turns };
+      }
+
+      return { id: task.id, success: true, content: "Sub-agent reached max turns.", tokensUsed: totalTokens, turns };
+    } catch (error) {
+      return { id: task.id, success: false, content: "", tokensUsed: totalTokens, turns, error: String(error) };
+    }
+  }
+
+  private getToolSchemas(allowedTools?: string[]) {
+    const all = this.tools.getToolSchemas();
+    if (!allowedTools) return all;
+    return all.filter((t) => allowedTools.includes(t.function.name));
+  }
+}

package/src/main.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * VORACODE — AI Coding Agent
+ * One agent, every surface.
+ *
+ * Premium CLI with ALL features integrated.
+ */
+
+import { Command } from "commander";
+import { runCommand } from "./cli/run";
+import { initCommand } from "./cli/init";
+import { sessionCommand } from "./cli/session";
+import { modelCommand } from "./cli/model";
+import { skillCommand } from "./cli/skill";
+import { keyCommand } from "./cli/key";
+import { configCommand } from "./cli/config";
+import { pluginCommand } from "./cli/plugin";
+import { mcpCommand } from "./cli/mcp";
+import { statsCommand } from "./cli/stats";
+import { doctorCommand } from "./cli/doctor";
+import { auditCommand } from "./cli/audit";
+import { liteCommand } from "./cli/lite";
+import { proCommand } from "./cli/pro";
+import { updateCommand } from "./cli/update";
+import { version } from "../package.json";
+import { c, printBanner, box, footer } from "./ui/theme";
+import { ALL_PROVIDERS, BUILTIN_MCP_SERVERS } from "./models/adapters/all-providers";
+
+const VERSION = version || "0.0.1";
+const NAME = "voracode";
+
+async function main(): Promise<void> {
+  const program = new Command();
+
+  program
+    .name(NAME)
+    .description(`${c.brand}${c.bold}${NAME}${c.reset} — ${c.dim}AI Coding Agent${c.reset}`)
+    .version(VERSION, "-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(`\n  ${c.error}✖ ${c.reset}${c.error}${error instanceof Error ? error.message : String(error)}${c.reset}\n`);
+  process.exit(1);
+});