voracode 0.0.1

package/src/tools/executor.ts

@@ -0,0 +1,362 @@
+/**
+ * VORACODE Tool Executor — Execute tool calls from the AI agent
+ *
+ * Each tool is a function that takes JSON arguments and returns a result.
+ * Tools are sandboxed, logged, and audited.
+ */
+
+import { VoraDatabase } from "../storage/database";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import { resolve } from "path";
+import type { ToolDefinition as RouterToolDef } from "../models/router";
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  execute: (args: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+
+// Blocked command patterns — case-insensitive
+const 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
+];
+
+// Project root for path validation
+const PROJECT_ROOT = resolve(process.cwd());
+
+export class ToolExecutor {
+  private db: VoraDatabase;
+  private tools: Map<string, ToolDefinition>;
+
+  constructor(db: VoraDatabase) {
+    this.db = db;
+    this.tools = new Map();
+    this.registerBuiltins();
+  }
+
+  private registerBuiltins(): void {
+    this.tools.set("file_read", {
+      name: "file_read",
+      description: "Read the contents of a file",
+      execute: (args) => this.fileRead(args.path as string),
+    });
+
+    this.tools.set("file_write", {
+      name: "file_write",
+      description: "Write content to a file",
+      execute: (args) => this.fileWrite(args.path as string, args.content as string),
+    });
+
+    this.tools.set("file_edit", {
+      name: "file_edit",
+      description: "Edit a file by replacing text",
+      execute: (args) => this.fileEdit(args.path as string, args.old_string as string, args.new_string as string),
+    });
+
+    this.tools.set("bash", {
+      name: "bash",
+      description: "Execute a shell command (sandboxed)",
+      execute: (args) => this.execBash(args.command as string),
+    });
+
+    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 as string]),
+    });
+
+    this.tools.set("code_search", {
+      name: "code_search",
+      description: "Search codebase for a pattern",
+      execute: (args) => this.searchCode(args.pattern as string, args.path as string),
+    });
+
+    this.tools.set("web_fetch", {
+      name: "web_fetch",
+      description: "Fetch content from a URL",
+      execute: (args) => this.webFetch(args.url as string),
+    });
+
+    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 as string),
+    });
+  }
+
+  /**
+   * Execute a tool by name with given arguments
+   */
+  async execute(toolName: string, argsJson: string): Promise<unknown> {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      return `Error: Unknown tool '${toolName}'. Available: ${Array.from(this.tools.keys()).join(", ")}`;
+    }
+
+    let args: Record<string, unknown> = {};
+    try {
+      args = JSON.parse(argsJson);
+    } catch {
+      return `Error: Invalid JSON arguments for tool '${toolName}'`;
+    }
+
+    // Audit log
+    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(): ToolDefinition[] {
+    return Array.from(this.tools.values());
+  }
+
+  /**
+   * Register a custom tool (for plugins)
+   */
+  registerTool(tool: ToolDefinition): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  /**
+   * Get tool definitions in OpenAI function-calling format
+   */
+  getToolSchemas(): RouterToolDef[] {
+    const schemas: RouterToolDef[] = [];
+    const paramSchemas: Record<string, { path: { type: string; description: string }; content: { type: string; description: string }; old_string: { type: string; description: string }; new_string: { type: string; description: string }; command: { type: string; description: string }; message: { type: string; description: string }; pattern: { type: string; description: string }; url: { type: string; description: string }; reasoning: { type: string; description: string } }> = {
+      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: Record<string, { type: string; description: string }> = {};
+      const required: string[] = [];
+      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 : undefined,
+          },
+        },
+      });
+    }
+
+    return schemas;
+  }
+
+  // ── Tool implementations ──
+
+  private validatePath(resolved: string): void {
+    const normalized = resolve(resolved);
+    if (!normalized.startsWith(PROJECT_ROOT)) {
+      throw new Error(`Path traversal blocked: '${resolved}' is outside project`);
+    }
+  }
+
+  private fileRead(path: string): string {
+    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 (!existsSync(resolved)) return `Error: File not found: ${path}`;
+    return readFileSync(resolved, "utf-8");
+  }
+
+  private fileWrite(path: string, content: string): string {
+    if (!path || content === undefined) 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}`;
+  }
+
+  private fileEdit(path: string, oldString: string, newString: string): string {
+    if (!path || !oldString || newString === undefined) 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 (!existsSync(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}"`;
+  }
+
+  private execBash(command: string): string {
+    if (!command) return "Error: command is required";
+
+    // Security: block dangerous commands
+    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: 30_000,
+        maxBuffer: 1_048_576,
+        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";
+    }
+  }
+
+  private execGit(args: string[]): string {
+    try {
+      const result = execSync(`git ${args.join(" ")}`, {
+        cwd: process.cwd(),
+        timeout: 10_000,
+        maxBuffer: 1_048_576,
+        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";
+    }
+  }
+
+  private searchCode(pattern: string, path = "."): string {
+    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: 10_000,
+        maxBuffer: 1_048_576,
+        encoding: "utf-8",
+        shell: isWin ? "cmd.exe" : "/bin/bash",
+      });
+      return result || "No matches found.";
+    } catch {
+      return "No matches found.";
+    }
+  }
+
+  private async webFetch(url: string): Promise<string> {
+    if (!url) return "Error: url is required";
+
+    // Security: block private IPs, localhost, etc.
+    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(10_000) });
+      const text = await response.text();
+      return text.slice(0, 10_000); // Limit response size
+    } catch (error) {
+      return `Error fetching URL: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  }
+
+  private listDir(path = "."): string {
+    const resolved = resolve(PROJECT_ROOT, path);
+    try { this.validatePath(resolved); } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : "invalid path"}`;
+    }
+    if (!existsSync(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: 5_000,
+        maxBuffer: 10_000,
+        encoding: "utf-8",
+        shell: isWin ? "cmd.exe" : "/bin/bash",
+      });
+      return result;
+    } catch {
+      return `Error: Could not list directory ${path}`;
+    }
+  }
+}

package/src/ui/theme.ts

@@ -0,0 +1,163 @@
+/**
+ * VORACODE Theme — Apple-inspired premium design system
+ *
+ * Consistent colors, typography, and spacing for all CLI output.
+ * Inspired by Apple's design language: minimal, clean, confident.
+ */
+
+import { version } from "../../package.json";
+
+const VERSION = version || "0.0.1";
+
+// ── Color Palette (ANSI 256-bit, cross-platform) ──
+
+export const 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",
+};
+
+// ── Icons (Unicode) ──
+
+export const icon = {
+  check: `${c.success}●${c.reset}`,
+  cross: `${c.error}●${c.reset}`,
+  warn: `${c.warning}●${c.reset}`,
+  info: `${c.info}●${c.reset}`,
+  arrow: `${c.brand}→${c.reset}`,
+  dot: `${c.dim}·${c.reset}`,
+  diamond: `${c.brand}◆${c.reset}`,
+  star: `${c.warning}★${c.reset}`,
+  bolt: `${c.cyan}⚡${c.reset}`,
+  shield: `${c.teal}◇${c.reset}`,
+  key: `${c.orange}◇${c.reset}`,
+  brain: `${c.purple || c.pink}◈${c.reset}`,
+};
+
+// ── Layout Helpers ──
+
+export function divider(char = "─", width = 48): string {
+  return `${c.dim}${char.repeat(width)}${c.reset}`;
+}
+
+export function indent(text: string, spaces = 4): string {
+  return text.split("\n").map((l) => " ".repeat(spaces) + l).join("\n");
+}
+
+// ── Box Drawing (Premium) ──
+
+export function box(lines: string[], width = 50): string {
+  const pad = (s: string, w: number) => s + " ".repeat(Math.max(0, w - s.length));
+  const top = `  ┌${"─".repeat(width)}┐`;
+  const bot = `  └${"─".repeat(width)}┘`;
+  const mid = lines.map((l) => `  │ ${pad(l, width - 1)}│`).join("\n");
+  return `${top}\n${mid}\n${bot}`;
+}
+
+// ── Branded Output ──
+
+export function branded(text: string): string {
+  return `${c.brand}${text}${c.reset}`;
+}
+
+export function success(text: string): string {
+  return `${icon.check}  ${text}`;
+}
+
+export function error(text: string): string {
+  return `${icon.cross}  ${text}`;
+}
+
+export function warning(text: string): string {
+  return `${icon.warn}  ${text}`;
+}
+
+export function info(text: string): string {
+  return `${icon.info}  ${text}`;
+}
+
+// ── Banner ──
+
+export function printBanner(): void {
+  console.log(`
+  ${c.brand}    ◆${c.reset}   ${c.bold}V O R A C O D E${c.reset}   ${c.brand}◆${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}·${c.reset}  ${c.muted}${new Date().toLocaleDateString() + " " + new Date().toLocaleTimeString()}${c.reset}
+  `);
+}
+
+// ── Command Banner ──
+
+export function commandBanner(title: string, subtitle?: string): void {
+  console.log(`
+  ${c.brand}◆${c.reset}  ${c.bold}${title}${c.reset}
+  ${c.dim}${subtitle || ""}${c.reset}
+  `);
+}
+
+// ── Status Line ──
+
+export function statusLine(label: string, value: string, type: "success" | "error" | "warning" | "info" | "dim" = "info"): string {
+  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}`;
+}
+
+// ── Table ──
+
+export function table(headers: string[], rows: string[][]): string {
+  const widths = headers.map((h, i) => {
+    const maxData = Math.max(...rows.map((r) => (r[i] || "").length));
+    return Math.max(h.length, maxData);
+  });
+
+  const line = `  ┌${widths.map((w) => "─".repeat(w + 2)).join("┬")}┐`;
+  const head = `  │${headers.map((h, i) => ` ${c.bold}${h.padEnd(widths[i])}${c.reset} │`).join("")}`;
+  const sep = `  ├${widths.map((w) => "─".repeat(w + 2)).join("┼")}┤`;
+  const body = rows.map((r) =>
+    `  │${r.map((cell, i) => ` ${cell.padEnd(widths[i])} │`).join("")}`
+  ).join("\n");
+
+  return `${line}\n${head}\n${sep}\n${body}\n${line}`;
+}
+
+// ── Progress ──
+
+export function spinner(text: string): string {
+  return `  ${c.brand}◆${c.reset}  ${text}`;
+}
+
+// ── Footer ──
+
+export function footer(): void {
+  console.log(`
+  ${c.dim}${c.brand}◆${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}
+  `);
+}