zero-ai-cli 1.0.0

package/packages/core/src/config/index.ts

@@ -0,0 +1,139 @@
+/**
+ * ZERO Configuration System
+ * Handles loading, validating, and managing ZERO configuration
+ *
+ * Sources:
+ * - gemini-cli: config with extensions
+ * - crush: JSON config with schema
+ * - opencode: configuration management
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ZeroConfig } from "../types.js";
+
+const CONFIG_FILE_NAME = "zero.config.json";
+const ZERO_DIR = ".zero";
+
+export const DEFAULT_CONFIG: ZeroConfig = {
+  version: 1,
+  defaultProvider: "openai",
+  defaultModel: "gpt-4o",
+  providers: {
+    openai: {
+      type: "openai",
+      apiKey: process.env.OPENAI_API_KEY,
+    },
+    anthropic: {
+      type: "anthropic",
+      apiKey: process.env.ANTHROPIC_API_KEY,
+    },
+    google: {
+      type: "google",
+      apiKey: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY,
+    },
+    ollama: {
+      type: "ollama",
+      baseUrl: "http://localhost:11434/v1",
+    },
+  },
+  permissions: {
+    fileRead: "allow",
+    fileWrite: "ask",
+    shellExecution: "ask",
+    networkAccess: "ask",
+    mcpAccess: "allow",
+  },
+};
+
+export class ConfigManager {
+  private config: ZeroConfig;
+  private configPath: string;
+  private projectPath: string;
+
+  constructor(projectPath: string) {
+    this.projectPath = projectPath;
+    this.configPath = path.join(projectPath, CONFIG_FILE_NAME);
+    this.config = { ...DEFAULT_CONFIG };
+  }
+
+  /**
+   * Load configuration from file
+   */
+  async load(): Promise<ZeroConfig> {
+    try {
+      const data = await fs.readFile(this.configPath, "utf-8");
+      const loaded = JSON.parse(data);
+      this.config = { ...DEFAULT_CONFIG, ...loaded };
+    } catch {
+      // Use defaults if config file doesn't exist
+      this.config = { ...DEFAULT_CONFIG };
+    }
+
+    // Also check for .zero/ directory config
+    try {
+      const zeroDirConfig = path.join(this.projectPath, ZERO_DIR, "config.json");
+      const data = await fs.readFile(zeroDirConfig, "utf-8");
+      const loaded = JSON.parse(data);
+      this.config = { ...this.config, ...loaded };
+    } catch {}
+
+    return this.config;
+  }
+
+  /**
+   * Save configuration to file
+   */
+  async save(): Promise<void> {
+    await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2));
+  }
+
+  /**
+   * Get current configuration
+   */
+  get(): ZeroConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Update configuration
+   */
+  update(partial: Partial<ZeroConfig>): ZeroConfig {
+    this.config = { ...this.config, ...partial };
+    return this.config;
+  }
+
+  /**
+   * Get the ZERO data directory path
+   */
+  getDataDir(): string {
+    return path.join(this.projectPath, ZERO_DIR);
+  }
+
+  /**
+   * Initialize ZERO project structure
+   */
+  async init(): Promise<void> {
+    const zeroDir = this.getDataDir();
+    await fs.mkdir(zeroDir, { recursive: true });
+    await fs.mkdir(path.join(zeroDir, "sessions"), { recursive: true });
+    await fs.mkdir(path.join(zeroDir, "memory"), { recursive: true });
+    await fs.mkdir(path.join(zeroDir, "logs"), { recursive: true });
+
+    // Create default config
+    await this.save();
+
+    // Create .gitignore for .zero directory
+    const gitignore = path.join(zeroDir, ".gitignore");
+    try {
+      await fs.writeFile(gitignore, "sessions/\nmemory/\nlogs/\n*.log\n");
+    } catch {}
+  }
+
+  /**
+   * Resolve environment variables in config
+   */
+  resolveEnv(value: string): string {
+    return value.replace(/\$\{(\w+)\}/g, (_, key) => process.env[key] || "");
+  }
+}

package/packages/core/src/confirmation/message-bus.ts

@@ -0,0 +1,206 @@
+/**
+ * ZERO Message Bus
+ * Adapted from: qwen-code (Alibaba) - MIT
+ *
+ * Event-driven message bus for tool confirmations and hook execution.
+ * Supports request-response patterns with correlation IDs.
+ */
+
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+
+export enum MessageBusType {
+  TOOL_CONFIRMATION_REQUEST = "tool-confirmation-request",
+  TOOL_CONFIRMATION_RESPONSE = "tool-confirmation-response",
+  TOOL_EXECUTION_SUCCESS = "tool-execution-success",
+  TOOL_EXECUTION_FAILURE = "tool-execution-failure",
+  HOOK_EXECUTION_REQUEST = "hook-execution-request",
+  HOOK_EXECUTION_RESPONSE = "hook-execution-response",
+}
+
+export interface ToolConfirmationRequest {
+  type: MessageBusType.TOOL_CONFIRMATION_REQUEST;
+  toolName: string;
+  toolArgs: Record<string, unknown>;
+  correlationId: string;
+  details?: SerializableConfirmationDetails;
+}
+
+export interface ToolConfirmationResponse {
+  type: MessageBusType.TOOL_CONFIRMATION_RESPONSE;
+  correlationId: string;
+  confirmed: boolean;
+  payload?: unknown;
+  requiresUserConfirmation?: boolean;
+}
+
+export type SerializableConfirmationDetails =
+  | {
+      type: "info";
+      title: string;
+      prompt: string;
+      urls?: string[];
+    }
+  | {
+      type: "edit";
+      title: string;
+      fileName: string;
+      filePath: string;
+      fileDiff: string;
+      originalContent: string | null;
+      newContent: string;
+    }
+  | {
+      type: "exec";
+      title: string;
+      command: string;
+      rootCommand: string;
+    }
+  | {
+      type: "mcp";
+      title: string;
+      serverName: string;
+      toolName: string;
+    };
+
+export interface ToolExecutionSuccess<T = unknown> {
+  type: MessageBusType.TOOL_EXECUTION_SUCCESS;
+  toolName: string;
+  result: T;
+}
+
+export interface ToolExecutionFailure {
+  type: MessageBusType.TOOL_EXECUTION_FAILURE;
+  toolName: string;
+  error: Error;
+}
+
+export interface HookExecutionRequest {
+  type: MessageBusType.HOOK_EXECUTION_REQUEST;
+  eventName: string;
+  input: Record<string, unknown>;
+  correlationId: string;
+  signal?: AbortSignal;
+}
+
+export interface HookExecutionResponse {
+  type: MessageBusType.HOOK_EXECUTION_RESPONSE;
+  correlationId: string;
+  success: boolean;
+  output?: Record<string, unknown>;
+  error?: Error;
+}
+
+export type Message =
+  | ToolConfirmationRequest
+  | ToolConfirmationResponse
+  | ToolExecutionSuccess
+  | ToolExecutionFailure
+  | HookExecutionRequest
+  | HookExecutionResponse;
+
+export class MessageBus extends EventEmitter {
+  private isValidMessage(message: Message): boolean {
+    if (!message || !message.type) {
+      return false;
+    }
+
+    if (
+      message.type === MessageBusType.TOOL_CONFIRMATION_REQUEST &&
+      !("correlationId" in message)
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  async publish(message: Message): Promise<void> {
+    try {
+      if (!this.isValidMessage(message)) {
+        throw new Error(`Invalid message structure: ${JSON.stringify(message)}`);
+      }
+
+      if (message.type === MessageBusType.TOOL_CONFIRMATION_REQUEST) {
+        // Auto-confirm by default
+        this.emit(MessageBusType.TOOL_CONFIRMATION_RESPONSE, {
+          type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+          correlationId: message.correlationId,
+          confirmed: true,
+        });
+      } else {
+        this.emit(message.type, message);
+      }
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+
+  subscribe<T extends Message>(
+    type: T["type"],
+    listener: (message: T) => void
+  ): void {
+    this.on(type, listener);
+  }
+
+  unsubscribe<T extends Message>(
+    type: T["type"],
+    listener: (message: T) => void
+  ): void {
+    this.off(type, listener);
+  }
+
+  /**
+   * Request-response pattern: Publish a message and wait for a correlated response
+   */
+  async request<TRequest extends Message, TResponse extends Message>(
+    request: Omit<TRequest, "correlationId">,
+    responseType: TResponse["type"],
+    timeoutMs: number = 60000,
+    signal?: AbortSignal
+  ): Promise<TResponse> {
+    const correlationId = randomUUID();
+
+    return new Promise<TResponse>((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new Error("Request aborted"));
+        return;
+      }
+
+      const timeoutId = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Request timed out waiting for ${responseType}`));
+      }, timeoutMs);
+
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        this.unsubscribe(responseType, responseHandler);
+        if (signal) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+      };
+
+      const abortHandler = () => {
+        cleanup();
+        reject(new Error("Request aborted"));
+      };
+
+      if (signal) {
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+
+      const responseHandler = (response: TResponse) => {
+        if (
+          "correlationId" in response &&
+          response.correlationId === correlationId
+        ) {
+          cleanup();
+          resolve(response);
+        }
+      };
+
+      this.subscribe<TResponse>(responseType, responseHandler);
+      this.publish({ ...request, correlationId } as TRequest);
+    });
+  }
+}

package/packages/core/src/diff/index.ts

@@ -0,0 +1,232 @@
+/**
+ * ZERO Diff System
+ * Smart file editing with diff generation and application
+ *
+ * Sources:
+ * - aider: search/replace diff editing, unified diff
+ * - cline: block-based editing
+ * - kilocode: precise file modification
+ * - crush: diff detection and application
+ */
+
+export interface DiffBlock {
+  type: "context" | "add" | "remove";
+  lineNumber: number;
+  content: string;
+}
+
+export interface FileDiff {
+  filePath: string;
+  oldContent: string;
+  newContent: string;
+  blocks: DiffBlock[];
+  stats: { added: number; removed: number; unchanged: number };
+}
+
+/**
+ * Generate a unified diff between two strings
+ */
+export function generateDiff(oldContent: string, newContent: string, filePath = "file"): FileDiff {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const blocks: DiffBlock[] = [];
+
+  let added = 0;
+  let removed = 0;
+  let unchanged = 0;
+
+  // Simple LCS-based diff
+  const lcs = computeLCS(oldLines, newLines);
+  let i = 0;
+  let j = 0;
+  let k = 0;
+
+  while (i < oldLines.length || j < newLines.length) {
+    if (k < lcs.length && i < oldLines.length && oldLines[i] === lcs[k] && j < newLines.length && newLines[j] === lcs[k]) {
+      blocks.push({ type: "context", lineNumber: i + 1, content: oldLines[i] });
+      unchanged++;
+      i++;
+      j++;
+      k++;
+    } else if (j < newLines.length && (k >= lcs.length || newLines[j] !== lcs[k])) {
+      blocks.push({ type: "add", lineNumber: j + 1, content: newLines[j] });
+      added++;
+      j++;
+    } else if (i < oldLines.length && (k >= lcs.length || oldLines[i] !== lcs[k])) {
+      blocks.push({ type: "remove", lineNumber: i + 1, content: oldLines[i] });
+      removed++;
+      i++;
+    }
+  }
+
+  return {
+    filePath,
+    oldContent,
+    newContent,
+    blocks,
+    stats: { added, removed, unchanged },
+  };
+}
+
+/**
+ * Format diff as unified diff string
+ */
+export function formatUnifiedDiff(diff: FileDiff): string {
+  const lines: string[] = [];
+  lines.push(`--- a/${diff.filePath}`);
+  lines.push(`+++ b/${diff.filePath}`);
+  lines.push(`@@ -1,${diff.oldContent.split("\n").length} +1,${diff.newContent.split("\n").length} @@`);
+
+  for (const block of diff.blocks) {
+    switch (block.type) {
+      case "context":
+        lines.push(` ${block.content}`);
+        break;
+      case "add":
+        lines.push(`+${block.content}`);
+        break;
+      case "remove":
+        lines.push(`-${block.content}`);
+        break;
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Apply a search/replace edit (aider-style)
+ */
+export function applySearchReplace(
+  content: string,
+  search: string,
+  replace: string,
+): { success: boolean; result: string; error?: string } {
+  const count = content.split(search).length - 1;
+
+  if (count === 0) {
+    return { success: false, result: content, error: "Search text not found in file" };
+  }
+
+  if (count > 1) {
+    return {
+      success: false,
+      result: content,
+      error: `Search text found ${count} times. Provide more context for unique match.`,
+    };
+  }
+
+  return {
+    success: true,
+    result: content.replace(search, replace),
+  };
+}
+
+/**
+ * Apply multiple search/replace blocks (aider-style multi-edit)
+ */
+export function applyMultiEdit(
+  content: string,
+  edits: Array<{ search: string; replace: string }>,
+): { success: boolean; result: string; errors: string[] } {
+  let result = content;
+  const errors: string[] = [];
+
+  for (let i = 0; i < edits.length; i++) {
+    const { search, replace } = edits[i];
+    const applied = applySearchReplace(result, search, replace);
+
+    if (!applied.success) {
+      errors.push(`Edit ${i + 1}: ${applied.error}`);
+    } else {
+      result = applied.result;
+    }
+  }
+
+  return { success: errors.length === 0, result, errors };
+}
+
+/**
+ * Smart merge: apply changes while preserving untouched sections
+ */
+export function smartMerge(
+  original: string,
+  modified: string,
+  base: string,
+): { success: boolean; result: string; conflicts: string[] } {
+  // Simple three-way merge
+  const origLines = original.split("\n");
+  const modLines = modified.split("\n");
+  const baseLines = base.split("\n");
+
+  const result: string[] = [];
+  const conflicts: string[] = [];
+
+  const maxLen = Math.max(origLines.length, modLines.length, baseLines.length);
+
+  for (let i = 0; i < maxLen; i++) {
+    const origLine = origLines[i] ?? "";
+    const modLine = modLines[i] ?? "";
+    const baseLine = baseLines[i] ?? "";
+
+    if (modLine === baseLine) {
+      // No change from base -> use original
+      result.push(origLine);
+    } else if (origLine === baseLine) {
+      // Change from base in modified -> use modified
+      result.push(modLine);
+    } else if (origLine === modLine) {
+      // Same change in both -> use either
+      result.push(origLine);
+    } else {
+      // Conflict
+      conflicts.push(`Line ${i + 1}: original="${origLine}" vs modified="${modLine}"`);
+      result.push(`<<<<<<< ORIGINAL`);
+      result.push(origLine);
+      result.push(`=======`);
+      result.push(modLine);
+      result.push(`>>>>>>> MODIFIED`);
+    }
+  }
+
+  return {
+    success: conflicts.length === 0,
+    result: result.join("\n"),
+    conflicts,
+  };
+}
+
+// Helper: Longest Common Subsequence
+function computeLCS(a: string[], b: string[]): string[] {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  // Backtrack to find LCS
+  const lcs: string[] = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      lcs.unshift(a[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+
+  return lcs;
+}