zero-ai-cli 1.0.0

package/packages/cli/src/index.ts

@@ -0,0 +1,271 @@
+#!/usr/bin/env bun
+/**
+ * ZERO CLI - Main Entry Point
+ *
+ * Command-line interface for ZERO AI Coding Assistant
+ * Inspired by: gemini-cli, crush, opencode CLI interfaces
+ */
+
+import { Command } from "commander";
+import {
+  ConfigManager,
+  ProviderRegistry,
+  ToolRegistry,
+  AgentRegistry,
+  DEFAULT_AGENTS,
+  SessionManager,
+  MCPManager,
+  FileMemoryStore,
+  ContextManager,
+  createPermissionHandler,
+  getAllBuiltinTools,
+  AgentEngine,
+  DEFAULT_PERMISSION_CONFIG,
+} from "@zero/core";
+import type { PermissionRequest, PermissionDecision, Message } from "@zero/core";
+import { runInteractive } from "./interactive.js";
+import { runOnce } from "./once.js";
+
+const program = new Command();
+
+program
+  .name("zero")
+  .description("ZERO - Unified AI Coding Assistant")
+  .version("1.0.0");
+
+// Default interactive mode
+program
+  .argument("[prompt]", "Initial prompt to send to ZERO")
+  .option("-m, --model <model>", "Model to use", "gpt-4o")
+  .option("-p, --provider <provider>", "LLM provider", "openai")
+  .option("-d, --directory <path>", "Working directory", process.cwd())
+  .option("--auto-approve", "Auto-approve all tool calls", false)
+  .option("--verbose", "Show verbose output", false)
+  .action(async (prompt, options) => {
+    const { zero, session, memory, contextManager } = await initializeZero(options);
+
+    if (prompt) {
+      await runOnce(zero, prompt, session.id, options);
+    } else {
+      await runInteractive(zero, session.id, memory, contextManager, options);
+    }
+  });
+
+// Init command
+program
+  .command("init")
+  .description("Initialize ZERO in the current project")
+  .action(async () => {
+    const config = new ConfigManager(process.cwd());
+    await config.init();
+    console.log("✅ ZERO initialized successfully!");
+    console.log(`   Config: ${config.configPath || "zero.config.json"}`);
+    console.log(`   Data: ${config.getDataDir()}`);
+  });
+
+// Config command
+program
+  .command("config")
+  .description("Show or modify ZERO configuration")
+  .option("--show", "Show current configuration")
+  .option("--set <key=value>", "Set a configuration value")
+  .action(async (options) => {
+    const config = new ConfigManager(process.cwd());
+    await config.load();
+
+    if (options.show || (!options.set)) {
+      console.log(JSON.stringify(config.get(), null, 2));
+    }
+
+    if (options.set) {
+      const [key, value] = options.set.split("=");
+      config.update({ [key]: value } as any);
+      await config.save();
+      console.log(`✅ Set ${key} = ${value}`);
+    }
+  });
+
+// Session management
+program
+  .command("sessions")
+  .description("List or manage sessions")
+  .option("--list", "List all sessions")
+  .option("--delete <id>", "Delete a session")
+  .action(async (options) => {
+    const config = new ConfigManager(process.cwd());
+    await config.load();
+    const sessionMgr = new SessionManager({
+      storagePath: `${config.getDataDir()}/sessions`,
+      defaultConfig: {},
+    });
+    await sessionMgr.loadAll();
+
+    if (options.delete) {
+      await sessionMgr.delete(options.delete);
+      console.log(`✅ Session ${options.delete} deleted`);
+      return;
+    }
+
+    const sessions = sessionMgr.list();
+    if (sessions.length === 0) {
+      console.log("No sessions found.");
+      return;
+    }
+
+    console.log("📋 Sessions:");
+    for (const s of sessions) {
+      const date = new Date(s.updatedAt).toLocaleString();
+      console.log(`  ${s.id} - ${s.name} (${s.messages.length} messages) - ${date}`);
+    }
+  });
+
+// Agents list
+program
+  .command("agents")
+  .description("List available agents")
+  .action(() => {
+    console.log("🤖 Available Agents:");
+    for (const agent of DEFAULT_AGENTS) {
+      console.log(`  ${agent.id}: ${agent.description}`);
+      console.log(`    Tools: ${agent.tools.join(", ")}`);
+      console.log(`    Max turns: ${agent.maxTurns}`);
+    }
+  });
+
+// Tools list
+program
+  .command("tools")
+  .description("List available tools")
+  .action(() => {
+    const tools = getAllBuiltinTools();
+    console.log("🔧 Available Tools:");
+    for (const tool of tools) {
+      const approval = tool.requiresApproval ? "⚠️  requires approval" : "✅ auto-approved";
+      console.log(`  ${tool.name} [${tool.category}] - ${approval}`);
+      console.log(`    ${tool.description.split("\n")[0]}`);
+    }
+  });
+
+// Providers list
+program
+  .command("providers")
+  .description("List available LLM providers")
+  .action(() => {
+    const registry = new ProviderRegistry();
+    registry.loadBuiltins();
+
+    console.log("🌐 Available Providers:");
+    for (const provider of registry.list()) {
+      console.log(`  ${provider.id}: ${provider.name}`);
+      for (const model of provider.models) {
+        console.log(`    ${model.id} - ${model.name} (${model.contextWindow} context)`);
+      }
+    }
+  });
+
+async function initializeZero(options: any) {
+  const config = new ConfigManager(options.directory || process.cwd());
+  await config.load();
+
+  // Initialize providers
+  const providerRegistry = new ProviderRegistry();
+  providerRegistry.loadBuiltins();
+
+  // Initialize tools
+  const toolRegistry = new ToolRegistry();
+  for (const tool of getAllBuiltinTools()) {
+    toolRegistry.register(tool);
+  }
+
+  // Initialize agents
+  const sessionMgr = new SessionManager({
+    storagePath: `${config.getDataDir()}/sessions`,
+    defaultConfig: {
+      provider: options.provider || config.get().defaultProvider,
+      model: options.model || config.get().defaultModel,
+      workingDirectory: options.directory || process.cwd(),
+    },
+  });
+  await sessionMgr.loadAll();
+
+  const session = await sessionMgr.create();
+
+  // Initialize memory
+  const memory = new FileMemoryStore(`${config.getDataDir()}/memory`);
+  await memory.init();
+  const contextManager = new ContextManager(memory);
+
+  // Create permission handler
+  let permissionHandler;
+  if (options.autoApprove) {
+    permissionHandler = async () => "allow" as PermissionDecision;
+  } else {
+    permissionHandler = createPermissionHandler(
+      DEFAULT_PERMISSION_CONFIG,
+      async (request: PermissionRequest) => {
+        // In CLI mode, ask the user
+        const readline = await import("node:readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise<PermissionDecision>((resolve) => {
+          rl.question(`\n⚠️  Permission required: ${request.type} - ${request.resource}\n   ${request.details || ""}\n   Allow? [y/n/a(lways)] `, (answer) => {
+            rl.close();
+            if (answer === "a") resolve("allow_always");
+            else if (answer === "y") resolve("allow");
+            else resolve("deny");
+          });
+        });
+      },
+    );
+  }
+
+  // Create agent registry
+  const agentRegistry = new AgentRegistry({
+    clientFactory: (model) => {
+      const modelId = model === "default" ? (options.model || config.get().defaultModel) : model;
+      const providerId = options.provider || config.get().defaultProvider;
+      const providerConfig = config.get().providers[providerId] || {};
+      return providerRegistry.createClient(providerId, {
+        model: modelId,
+        apiKey: providerConfig.apiKey,
+        baseUrl: providerConfig.baseUrl,
+      });
+    },
+    tools: toolRegistry.getMap(),
+    permissionHandler,
+    workingDirectory: options.directory || process.cwd(),
+    sessionId: session.id,
+  });
+
+  // Register default agents
+  for (const agent of DEFAULT_AGENTS) {
+    agentRegistry.register(agent);
+  }
+
+  // Initialize MCP
+  const mcpManager = new MCPManager();
+  const mcpServers = config.get().mcpServers || [];
+  for (const server of mcpServers) {
+    await mcpManager.connect(server);
+  }
+
+  // Register MCP tools
+  for (const tool of mcpManager.getToolsAsDefinitions()) {
+    toolRegistry.register(tool);
+  }
+
+  return {
+    zero: {
+      agentRegistry,
+      toolRegistry,
+      providerRegistry,
+      sessionMgr,
+      mcpManager,
+      config,
+    },
+    session,
+    memory,
+    contextManager,
+  };
+}
+
+program.parse();

package/packages/cli/src/interactive.ts

@@ -0,0 +1,190 @@
+/**
+ * ZERO CLI - Interactive Mode
+ * REPL interface with streaming, colors, and tool approval
+ */
+
+import * as readline from "node:readline";
+import chalk from "chalk";
+import type { AgentEngine, Message, FileMemoryStore, ContextManager } from "@zero/core";
+
+interface ZeroRuntime {
+  agentRegistry: any;
+  toolRegistry: any;
+  providerRegistry: any;
+  sessionMgr: any;
+  mcpManager: any;
+  config: any;
+}
+
+const BANNER = `
+${chalk.bold.hex("#8B5CF6")("╔═══════════════════════════════════════╗")}
+${chalk.bold.hex("#8B5CF6")("║")}   ${chalk.bold.white("ZERO")} ${chalk.gray("v1.0.0")} — ${chalk.gray("Unified AI Assistant")}  ${chalk.bold.hex("#8B5CF6")("║")}
+${chalk.bold.hex("#8B5CF6")("║")}   ${chalk.gray("Type your message or /help")}           ${chalk.bold.hex("#8B5CF6")("║")}
+${chalk.bold.hex("#8B5CF6")("╚═══════════════════════════════════════╝")}
+`;
+
+export async function runInteractive(
+  zero: ZeroRuntime,
+  sessionId: string,
+  memory: FileMemoryStore,
+  contextManager: ContextManager,
+  options: any,
+): Promise<void> {
+  console.log(BANNER);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const prompt = () => {
+    rl.question(chalk.hex("#8B5CF6")("❯ "), async (input) => {
+      input = input.trim();
+
+      if (!input) {
+        prompt();
+        return;
+      }
+
+      // Handle commands
+      if (input.startsWith("/")) {
+        await handleCommand(input, zero, rl);
+        prompt();
+        return;
+      }
+
+      // Build context from memory
+      const context = await contextManager.buildContext(input);
+
+      // Create agent engine
+      const engine = zero.agentRegistry.createEngine("coder");
+
+      // Add context if available
+      let fullPrompt = input;
+      if (context) {
+        fullPrompt = `${input}\n\n${context}`;
+      }
+
+      // Run agent
+      console.log(chalk.gray("\n⚡ Processing...\n"));
+
+      const result = await engine.run(fullPrompt);
+
+      // Display results
+      for (const message of result.messages) {
+        if (message.role === "assistant") {
+          for (const content of message.content) {
+            if (content.type === "text") {
+              console.log(chalk.white(content.text));
+            } else if (content.type === "tool_call") {
+              console.log(chalk.yellow(`\n🔧 Tool: ${content.name}`));
+              console.log(chalk.gray(`   Args: ${JSON.stringify(content.arguments)}`));
+            }
+          }
+        } else if (message.role === "tool") {
+          for (const content of message.content) {
+            if (content.type === "tool_result") {
+              if (content.error) {
+                console.log(chalk.red(`   ❌ ${content.error}`));
+              } else {
+                const output = typeof content.result === "string" ? content.result : JSON.stringify(content.result);
+                const preview = output.length > 500 ? output.slice(0, 500) + "..." : output;
+                console.log(chalk.green(`   ✓ ${preview}`));
+              }
+            }
+          }
+        }
+      }
+
+      // Show usage stats
+      console.log(chalk.gray(`\n📊 Tokens: ${result.tokenUsage.inputTokens} in / ${result.tokenUsage.outputTokens} out | Duration: ${(result.duration / 1000).toFixed(1)}s`));
+
+      // Save important facts to memory
+      await contextManager.saveFact(`User asked: ${input}`, ["conversation"]);
+
+      prompt();
+    });
+  };
+
+  prompt();
+}
+
+async function handleCommand(input: string, zero: ZeroRuntime, rl: readline.Interface): Promise<void> {
+  const [command, ...args] = input.slice(1).split(" ");
+
+  switch (command) {
+    case "help":
+      console.log(`
+${chalk.bold("Commands:")}
+  ${chalk.cyan("/help")}          Show this help message
+  ${chalk.cyan("/clear")}         Clear the conversation
+  ${chalk.cyan("/model <name>")}  Switch to a different model
+  ${chalk.cyan("/provider <id>")} Switch to a different provider
+  ${chalk.cyan("/agents")}        List available agents
+  ${chalk.cyan("/tools")}         List available tools
+  ${chalk.cyan("/memory")}        Show stored memories
+  ${chalk.cyan("/session")}       Show session info
+  ${chalk.cyan("/quit")}          Exit ZERO
+`);
+      break;
+
+    case "clear":
+      console.clear();
+      console.log(chalk.gray("Conversation cleared."));
+      break;
+
+    case "model":
+      if (args[0]) {
+        console.log(chalk.green(`✅ Model switched to: ${args[0]}`));
+      } else {
+        console.log(chalk.yellow("Usage: /model <model-name>"));
+      }
+      break;
+
+    case "provider":
+      if (args[0]) {
+        console.log(chalk.green(`✅ Provider switched to: ${args[0]}`));
+      } else {
+        console.log(chalk.yellow("Usage: /provider <provider-id>"));
+      }
+      break;
+
+    case "agents":
+      const agents = zero.agentRegistry.list();
+      console.log(chalk.bold("\n🤖 Agents:"));
+      for (const agent of agents) {
+        console.log(`  ${chalk.cyan(agent.id)}: ${agent.description}`);
+      }
+      break;
+
+    case "tools":
+      const tools = zero.toolRegistry.getAll();
+      console.log(chalk.bold("\n🔧 Tools:"));
+      for (const tool of tools) {
+        console.log(`  ${chalk.cyan(tool.name)} [${tool.category}]`);
+      }
+      break;
+
+    case "memory":
+      const memory = zero.memory || [];
+      console.log(chalk.bold("\n🧠 Memory:"));
+      if (memory.length === 0) {
+        console.log(chalk.gray("  No memories stored."));
+      }
+      break;
+
+    case "session":
+      console.log(chalk.bold("\n📋 Session Info:"));
+      console.log(`  Status: Active`);
+      break;
+
+    case "quit":
+    case "exit":
+    case "q":
+      console.log(chalk.gray("\n👋 Goodbye!"));
+      process.exit(0);
+
+    default:
+      console.log(chalk.red(`Unknown command: /${command}. Type /help for available commands.`));
+  }
+}

package/packages/cli/src/once.ts

@@ -0,0 +1,50 @@
+/**
+ * ZERO CLI - One-shot Mode
+ * Execute a single prompt and exit
+ */
+
+import chalk from "chalk";
+import type { AgentEngine } from "@zero/core";
+
+interface ZeroRuntime {
+  agentRegistry: any;
+  toolRegistry: any;
+  providerRegistry: any;
+  sessionMgr: any;
+  mcpManager: any;
+  config: any;
+}
+
+export async function runOnce(
+  zero: ZeroRuntime,
+  prompt: string,
+  sessionId: string,
+  options: any,
+): Promise<void> {
+  const engine = zero.agentRegistry.createEngine("coder");
+
+  if (options.verbose) {
+    console.log(chalk.gray(`Provider: ${options.provider || "openai"}`));
+    console.log(chalk.gray(`Model: ${options.model || "gpt-4o"}`));
+    console.log(chalk.gray(`Directory: ${options.directory || process.cwd()}`));
+    console.log("");
+  }
+
+  const result = await engine.run(prompt);
+
+  // Output results
+  for (const message of result.messages) {
+    if (message.role === "assistant") {
+      for (const content of message.content) {
+        if (content.type === "text") {
+          console.log(content.text);
+        } else if (content.type === "tool_call" && options.verbose) {
+          console.error(chalk.yellow(`[Tool: ${content.name}]`));
+        }
+      }
+    }
+  }
+
+  // Exit with appropriate code
+  process.exit(result.success ? 0 : 1);
+}

package/packages/core/src/agent/config-loader.ts

@@ -0,0 +1,174 @@
+/**
+ * ZERO Agent Config Loader
+ * Adapted from: cline - Apache 2.0
+ *
+ * Loads agent configurations from YAML/Markdown frontmatter files.
+ * Supports file watching for dynamic agent reloading.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { AgentConfig, ToolCategory } from "../types.js";
+
+/**
+ * Built-in tool names available for agents
+ */
+export const BUILTIN_TOOLS = [
+  "read_file",
+  "write_file",
+  "edit_file",
+  "list_directory",
+  "search_files",
+  "search_code",
+  "execute_shell",
+  "git_status",
+  "git_diff",
+  "git_commit",
+  "web_fetch",
+  "web_search",
+  "delegate_to_agent",
+] as const;
+
+export type BuiltinTool = (typeof BUILTIN_TOOLS)[number];
+
+/**
+ * Schema for agent configuration in YAML frontmatter
+ */
+export interface AgentFrontmatterConfig {
+  name: string;
+  description: string;
+  modelId?: string;
+  tools?: string | string[];
+  skills?: string | string[];
+  maxTurns?: number;
+}
+
+/**
+ * Parse YAML frontmatter from a markdown file
+ */
+export function parseFrontmatter(content: string): { frontmatter: Record<string, unknown>; body: string } {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+
+  const yamlStr = match[1];
+  const body = match[2];
+
+  // Simple YAML parser for key: value pairs
+  const frontmatter: Record<string, unknown> = {};
+  const lines = yamlStr.split("\n");
+  let currentKey = "";
+  let currentArray: string[] = [];
+  let inArray = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    if (trimmed.startsWith("- ") && inArray) {
+      currentArray.push(trimmed.slice(2).trim());
+      continue;
+    }
+
+    if (inArray && currentKey) {
+      frontmatter[currentKey] = currentArray;
+      inArray = false;
+      currentArray = [];
+    }
+
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx > 0) {
+      const key = trimmed.slice(0, colonIdx).trim();
+      const value = trimmed.slice(colonIdx + 1).trim();
+
+      if (value === "" || value === "[]") {
+        currentKey = key;
+        inArray = true;
+        currentArray = [];
+      } else {
+        frontmatter[key] = value.replace(/^["']|["']$/g, "");
+      }
+    }
+  }
+
+  if (inArray && currentKey) {
+    frontmatter[currentKey] = currentArray;
+  }
+
+  return { frontmatter, body };
+}
+
+/**
+ * Parse tools from config (string or array)
+ */
+function parseTools(tools: string | string[] | undefined): string[] {
+  if (!tools) return [...BUILTIN_TOOLS].filter((t) => t !== "delegate_to_agent");
+
+  const rawTools = Array.isArray(tools) ? tools : tools.split(",").map((t) => t.trim());
+  return Array.from(new Set(rawTools.filter((t) => BUILTIN_TOOLS.includes(t as BuiltinTool))));
+}
+
+/**
+ * Parse skills from config
+ */
+function parseSkills(skills: string | string[] | undefined): string[] {
+  if (!skills) return [];
+  return Array.isArray(skills) ? skills : skills.split(",").map((s) => s.trim());
+}
+
+/**
+ * Load an agent configuration from a markdown file
+ */
+export async function loadAgentFromFile(filePath: string): Promise<AgentConfig> {
+  const content = await fs.readFile(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+
+  const config = frontmatter as unknown as AgentFrontmatterConfig;
+
+  if (!config.name) {
+    throw new Error(`Agent config in ${filePath} missing required field: name`);
+  }
+
+  if (!config.description) {
+    throw new Error(`Agent config in ${filePath} missing required field: description`);
+  }
+
+  const id = path.basename(filePath, path.extname(filePath)).toLowerCase().replace(/[^a-z0-9]/g, "-");
+
+  return {
+    id,
+    name: config.name,
+    description: config.description,
+    systemPrompt: body.trim() || `You are ${config.name}, a specialized agent.`,
+    tools: parseTools(config.tools),
+    maxTurns: config.maxTurns || 50,
+    model: config.modelId || "default",
+  };
+}
+
+/**
+ * Load all agent configurations from a directory
+ */
+export async function loadAgentsFromDirectory(dirPath: string): Promise<AgentConfig[]> {
+  const agents: AgentConfig[] = [];
+
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".yaml"))) {
+        try {
+          const agent = await loadAgentFromFile(path.join(dirPath, entry.name));
+          agents.push(agent);
+        } catch (error) {
+          // Skip invalid files
+        }
+      }
+    }
+  } catch {
+    // Directory doesn't exist
+  }
+
+  return agents;
+}