@c4ccz/zero 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4ccz/zero",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "ZERO - Unified AI Coding Assistant. Merges 9 open-source AI coding projects into one powerful tool.",
   "type": "module",
   "main": "./packages/core/src/index.ts",
@@ -15,6 +15,12 @@
     "./sdk": "./packages/sdk/src/index.ts",
     "./tui": "./packages/tui/src/index.ts"
   },
+  "files": [
+    "packages/",
+    "README.md",
+    "MERGE_REPORT.md",
+    "tsconfig.json"
+  ],
   "scripts": {
     "build": "echo 'ZERO uses Bun runtime - no build step required'",
     "dev": "bun run packages/cli/src/index.ts",
@@ -27,19 +33,16 @@
     "gemini", "openai", "anthropic", "claude", "aider",
     "code-generation", "developer-tools", "zero"
   ],
-  "author": "ZERO Project",
+  "author": "c4ccz",
   "license": "MIT",
   "engines": {
     "node": ">=20.0.0"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/zero-ai/zero"
-  },
-  "bugs": {
-    "url": "https://github.com/zero-ai/zero/issues"
+    "url": "git+https://github.com/c4ccz/zero.git"
   },
-  "homepage": "https://github.com/zero-ai/zero#readme",
+  "homepage": "https://github.com/c4ccz/zero#readme",
   "dependencies": {
     "zod": "^3.23.0",
     "chalk": "^5.3.0",

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;
+}

package/packages/core/src/agent/engine.ts

@@ -0,0 +1,266 @@
+/**
+ * ZERO Agent Engine
+ * Core agent loop implementation combining best patterns from:
+ * - goose: sub-agent orchestration
+ * - gemini-cli: ReAct loop with tool execution
+ * - pi: multi-agent orchestrator
+ * - cline: tool approval flow
+ */
+
+import type {
+  AgentConfig,
+  AgentResult,
+  ChatOptions,
+  LLMClient,
+  Message,
+  MessageContent,
+  ToolCallContent,
+  ToolDefinition,
+  ToolResult,
+  TokenUsage,
+  PermissionHandler,
+  SessionState,
+} from "../types.js";
+
+export interface AgentEngineOptions {
+  config: AgentConfig;
+  client: LLMClient;
+  tools: Map<string, ToolDefinition>;
+  permissionHandler: PermissionHandler;
+  workingDirectory: string;
+  sessionId: string;
+  onStateChange?: (state: SessionState) => void;
+  onMessage?: (message: Message) => void;
+}
+
+export class AgentEngine {
+  private config: AgentConfig;
+  private client: LLMClient;
+  private tools: Map<string, ToolDefinition>;
+  private permissionHandler: PermissionHandler;
+  private workingDirectory: string;
+  private sessionId: string;
+  private messages: Message[] = [];
+  private totalUsage: TokenUsage = { inputTokens: 0, outputTokens: 0 };
+  private turnCount = 0;
+  private aborted = false;
+  private abortController = new AbortController();
+  private onStateChange?: (state: SessionState) => void;
+  private onMessage?: (message: Message) => void;
+
+  constructor(options: AgentEngineOptions) {
+    this.config = options.config;
+    this.client = options.client;
+    this.tools = options.tools;
+    this.permissionHandler = options.permissionHandler;
+    this.workingDirectory = options.workingDirectory;
+    this.sessionId = options.sessionId;
+    this.onStateChange = options.onStateChange;
+    this.onMessage = options.onMessage;
+  }
+
+  /**
+   * Run the agent loop with a user message
+   */
+  async run(userMessage: string): Promise<AgentResult> {
+    const startTime = Date.now();
+    this.aborted = false;
+    this.turnCount = 0;
+
+    // Add user message
+    const userMsg: Message = {
+      id: this.generateId(),
+      role: "user",
+      content: [{ type: "text", text: userMessage }],
+      timestamp: Date.now(),
+    };
+    this.messages.push(userMsg);
+    this.onMessage?.(userMsg);
+
+    try {
+      // Agent loop (ReAct pattern)
+      while (this.turnCount < this.config.maxTurns && !this.aborted) {
+        this.turnCount++;
+        this.updateState({ status: "running", currentAgent: this.config.name, tokenUsage: this.totalUsage });
+
+        // Get available tools for this agent
+        const availableTools = this.getAvailableTools();
+
+        // Call LLM
+        const chatOptions: ChatOptions = {
+          tools: availableTools.length > 0 ? availableTools : undefined,
+          systemPrompt: this.config.systemPrompt,
+        };
+
+        const response = await this.client.chat(this.messages, chatOptions);
+
+        // Track usage
+        this.totalUsage.inputTokens += response.usage.inputTokens;
+        this.totalUsage.outputTokens += response.usage.outputTokens;
+
+        // Add assistant message
+        const assistantMsg: Message = {
+          id: this.generateId(),
+          role: "assistant",
+          content: response.content,
+          timestamp: Date.now(),
+          metadata: { model: response.model, usage: response.usage },
+        };
+        this.messages.push(assistantMsg);
+        this.onMessage?.(assistantMsg);
+
+        // Check if we should stop
+        if (response.stopReason === "end_turn" || response.stopReason === "max_tokens") {
+          break;
+        }
+
+        // Process tool calls
+        if (response.stopReason === "tool_use") {
+          const toolCalls = response.content.filter(
+            (c): c is ToolCallContent => c.type === "tool_call"
+          );
+
+          for (const toolCall of toolCalls) {
+            const result = await this.executeTool(toolCall);
+            const toolResultMsg: Message = {
+              id: this.generateId(),
+              role: "tool",
+              content: [{
+                type: "tool_result",
+                id: toolCall.id,
+                name: toolCall.name,
+                result: result.output,
+                error: result.error,
+              }],
+              timestamp: Date.now(),
+            };
+            this.messages.push(toolResultMsg);
+            this.onMessage?.(toolResultMsg);
+          }
+        }
+      }
+
+      const duration = Date.now() - startTime;
+      const result: AgentResult = {
+        success: !this.aborted,
+        messages: this.messages,
+        tokenUsage: this.totalUsage,
+        duration,
+      };
+
+      this.updateState({ status: "completed", tokenUsage: this.totalUsage });
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.updateState({ status: "error", tokenUsage: this.totalUsage, error: errorMessage });
+      return {
+        success: false,
+        messages: this.messages,
+        tokenUsage: this.totalUsage,
+        duration,
+        error: errorMessage,
+      };
+    }
+  }
+
+  /**
+   * Execute a single tool call with permission checking
+   */
+  private async executeTool(toolCall: ToolCallContent): Promise<ToolResult> {
+    const tool = this.tools.get(toolCall.name);
+
+    if (!tool) {
+      return {
+        success: false,
+        output: "",
+        error: `Tool "${toolCall.name}" not found`,
+      };
+    }
+
+    // Check permissions if tool requires approval
+    if (tool.requiresApproval) {
+      this.updateState({ status: "waiting_approval", tokenUsage: this.totalUsage });
+
+      const decision = await this.permissionHandler({
+        type: this.getPermissionType(tool.category),
+        resource: toolCall.name,
+        details: JSON.stringify(toolCall.arguments),
+      });
+
+      if (decision === "deny") {
+        return {
+          success: false,
+          output: "",
+          error: "Permission denied by user",
+        };
+      }
+
+      this.updateState({ status: "running", tokenUsage: this.totalUsage });
+    }
+
+    // Execute the tool
+    try {
+      const result = await tool.handler(toolCall.arguments, {
+        sessionId: this.sessionId,
+        workingDirectory: this.workingDirectory,
+        permissions: {
+          fileRead: "allow",
+          fileWrite: tool.requiresApproval ? "allow" : "ask",
+          shellExecution: tool.requiresApproval ? "allow" : "ask",
+          networkAccess: "allow",
+          mcpAccess: "allow",
+        },
+        abortSignal: this.abortController.signal,
+      });
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Get tools available to this agent
+   */
+  private getAvailableTools(): ToolDefinition[] {
+    return this.config.tools
+      .map((name) => this.tools.get(name))
+      .filter((t): t is ToolDefinition => t !== undefined);
+  }
+
+  private getPermissionType(category: string): "file_read" | "file_write" | "shell" | "network" | "mcp" {
+    switch (category) {
+      case "file": return "file_write";
+      case "shell": return "shell";
+      case "web": return "network";
+      case "mcp": return "mcp";
+      default: return "file_read";
+    }
+  }
+
+  abort(): void {
+    this.aborted = true;
+    this.abortController.abort();
+  }
+
+  getMessages(): Message[] {
+    return [...this.messages];
+  }
+
+  private updateState(partial: Partial<SessionState>): void {
+    this.onStateChange?.({
+      status: partial.status ?? "idle",
+      currentAgent: partial.currentAgent ?? this.config.name,
+      tokenUsage: partial.tokenUsage ?? this.totalUsage,
+      error: partial.error,
+    });
+  }
+
+  private generateId(): string {
+    return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+}

package/packages/core/src/agent/registry-tools.ts

@@ -0,0 +1,58 @@
+/**
+ * ZERO Tool Registry
+ * Manages all available tools for agents
+ */
+
+import type { ToolDefinition, ToolCategory } from "../types.js";
+
+export class ToolRegistry {
+  private tools = new Map<string, ToolDefinition>();
+
+  register(tool: ToolDefinition): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  unregister(name: string): void {
+    this.tools.delete(name);
+  }
+
+  get(name: string): ToolDefinition | undefined {
+    return this.tools.get(name);
+  }
+
+  getAll(): ToolDefinition[] {
+    return Array.from(this.tools.values());
+  }
+
+  getByCategory(category: ToolCategory): ToolDefinition[] {
+    return this.getAll().filter((t) => t.category === category);
+  }
+
+  getMap(): Map<string, ToolDefinition> {
+    return new Map(this.tools);
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  names(): string[] {
+    return Array.from(this.tools.keys());
+  }
+
+  /**
+   * Load all built-in tools
+   */
+  loadBuiltins(): void {
+    const builtins = getBuiltinTools();
+    for (const tool of builtins) {
+      this.register(tool);
+    }
+  }
+}
+
+// Lazy import to avoid circular deps - tools are loaded at runtime
+function getBuiltinTools(): ToolDefinition[] {
+  // Will be populated by the tools/index.ts
+  return [];
+}