zero-ai-cli 1.0.0

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

@@ -0,0 +1,207 @@
+/**
+ * ZERO Diff Detect Service
+ * Adapted from: crush (Charm) - MIT
+ *
+ * Detects diffs between file versions and provides
+ * intelligent change analysis.
+ */
+
+import * as fs from "node:fs/promises";
+
+export interface DiffStats {
+  additions: number;
+  deletions: number;
+  modifications: number;
+  totalChanges: number;
+}
+
+export interface DiffHunk {
+  oldStart: number;
+  oldLines: number;
+  newStart: number;
+  newLines: number;
+  lines: DiffLine[];
+}
+
+export interface DiffLine {
+  type: "context" | "add" | "remove";
+  content: string;
+  oldLineNumber?: number;
+  newLineNumber?: number;
+}
+
+export interface FileDiff {
+  filePath: string;
+  stats: DiffStats;
+  hunks: DiffHunk[];
+}
+
+/**
+ * Detect diff between two strings
+ */
+export function detectDiff(before: string, after: string, filePath = "file"): FileDiff {
+  const beforeLines = before.split("\n");
+  const afterLines = after.split("\n");
+
+  const hunks: DiffHunk[] = [];
+  let additions = 0;
+  let deletions = 0;
+  let modifications = 0;
+
+  // Simple line-by-line diff using LCS
+  const lcs = computeLCS(beforeLines, afterLines);
+
+  let i = 0;
+  let j = 0;
+  let k = 0;
+  const lines: DiffLine[] = [];
+
+  while (i < beforeLines.length || j < afterLines.length) {
+    if (k < lcs.length && i < beforeLines.length && beforeLines[i] === lcs[k] && j < afterLines.length && afterLines[j] === lcs[k]) {
+      lines.push({
+        type: "context",
+        content: beforeLines[i],
+        oldLineNumber: i + 1,
+        newLineNumber: j + 1,
+      });
+      i++;
+      j++;
+      k++;
+    } else if (j < afterLines.length && (k >= lcs.length || afterLines[j] !== lcs[k])) {
+      lines.push({
+        type: "add",
+        content: afterLines[j],
+        newLineNumber: j + 1,
+      });
+      additions++;
+      j++;
+    } else if (i < beforeLines.length && (k >= lcs.length || beforeLines[i] !== lcs[k])) {
+      lines.push({
+        type: "remove",
+        content: beforeLines[i],
+        oldLineNumber: i + 1,
+      });
+      deletions++;
+      i++;
+    }
+  }
+
+  // Group lines into hunks
+  if (lines.length > 0) {
+    hunks.push({
+      oldStart: 1,
+      oldLines: beforeLines.length,
+      newStart: 1,
+      newLines: afterLines.length,
+      lines,
+    });
+  }
+
+  // Detect modifications (paired add/remove)
+  const minAddDel = Math.min(additions, deletions);
+  modifications = minAddDel;
+  additions -= minAddDel;
+  deletions -= minAddDel;
+
+  return {
+    filePath,
+    stats: {
+      additions,
+      deletions,
+      modifications,
+      totalChanges: additions + deletions + modifications,
+    },
+    hunks,
+  };
+}
+
+/**
+ * Detect diff between two files
+ */
+export async function detectFileDiff(beforePath: string, afterPath: string): Promise<FileDiff> {
+  const [before, after] = await Promise.all([
+    fs.readFile(beforePath, "utf-8").catch(() => ""),
+    fs.readFile(afterPath, "utf-8").catch(() => ""),
+  ]);
+
+  return detectDiff(before, after, afterPath);
+}
+
+/**
+ * Format diff as unified diff string
+ */
+export function formatDiff(diff: FileDiff): string {
+  const lines: string[] = [];
+  lines.push(`--- a/${diff.filePath}`);
+  lines.push(`+++ b/${diff.filePath}`);
+
+  for (const hunk of diff.hunks) {
+    lines.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
+
+    for (const line of hunk.lines) {
+      switch (line.type) {
+        case "context":
+          lines.push(` ${line.content}`);
+          break;
+        case "add":
+          lines.push(`+${line.content}`);
+          break;
+        case "remove":
+          lines.push(`-${line.content}`);
+          break;
+      }
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Get summary of changes
+ */
+export function summarizeDiff(diff: FileDiff): string {
+  const { additions, deletions, modifications } = diff.stats;
+  const parts: string[] = [];
+
+  if (additions > 0) parts.push(`+${additions} added`);
+  if (deletions > 0) parts.push(`-${deletions} removed`);
+  if (modifications > 0) parts.push(`~${modifications} modified`);
+
+  return parts.length > 0
+    ? `${diff.filePath}: ${parts.join(", ")}`
+    : `${diff.filePath}: no changes`;
+}
+
+// LCS helper
+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]);
+      }
+    }
+  }
+
+  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;
+}

package/packages/core/src/edit-coder/index.ts

@@ -0,0 +1,194 @@
+/**
+ * ZERO EditBlock Coder
+ * Adapted from: aider (Python) - Apache 2.0
+ *
+ * Aider-style edit block system that uses SEARCH/REPLACE blocks
+ * for precise, multi-location file editing.
+ *
+ * Format:
+ * ```
+ * <<<<<<< SEARCH
+ * exact text to find
+ * =======
+ * replacement text
+ * >>>>>>> REPLACE
+ * ```
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ToolDefinition, ToolResult } from "../types.js";
+
+export interface EditBlock {
+  search: string;
+  replace: string;
+  lineNumber?: number;
+}
+
+export interface EditBlockResult {
+  filePath: string;
+  applied: number;
+  failed: number;
+  errors: string[];
+  diff: string;
+}
+
+/**
+ * Parse edit blocks from LLM output
+ */
+export function parseEditBlocks(content: string): EditBlock[] {
+  const blocks: EditBlock[] = [];
+  const regex = /<<<<<<< SEARCH\n([\s\S]*?)=======\n([\s\S]*?)>>>>>>> REPLACE/g;
+
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    blocks.push({
+      search: match[1],
+      replace: match[2],
+    });
+  }
+
+  return blocks;
+}
+
+/**
+ * Apply edit blocks to file content
+ */
+export function applyEditBlocks(content: string, blocks: EditBlock[]): { result: string; applied: number; errors: string[] } {
+  let result = content;
+  let applied = 0;
+  const errors: string[] = [];
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const searchStr = block.search;
+
+    // Find the search text
+    const idx = result.indexOf(searchStr);
+    if (idx === -1) {
+      // Try fuzzy match (trim whitespace differences)
+      const trimmedSearch = searchStr.trim();
+      const lines = result.split("\n");
+      let found = false;
+
+      for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const windowSize = trimmedSearch.split("\n").length;
+        const window = lines.slice(lineIdx, lineIdx + windowSize).join("\n").trim();
+
+        if (window === trimmedSearch) {
+          // Found a fuzzy match
+          const beforeLines = lines.slice(0, lineIdx).join("\n");
+          const afterLines = lines.slice(lineIdx + windowSize).join("\n");
+          result = (beforeLines ? beforeLines + "\n" : "") + block.replace.trimEnd() + (afterLines ? "\n" + afterLines : "");
+          applied++;
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        errors.push(`Block ${i + 1}: Search text not found`);
+      }
+    } else {
+      // Exact match found
+      const count = result.split(searchStr).length - 1;
+      if (count > 1) {
+        errors.push(`Block ${i + 1}: Search text found ${count} times (need unique match)`);
+      } else {
+        result = result.replace(searchStr, block.replace);
+        applied++;
+      }
+    }
+  }
+
+  return { result, applied, errors };
+}
+
+/**
+ * Apply edit blocks to a file
+ */
+export async function applyEditBlocksToFile(filePath: string, blocks: EditBlock[], workingDir: string): Promise<EditBlockResult> {
+  const fullPath = path.resolve(workingDir, filePath);
+
+  try {
+    const content = await fs.readFile(fullPath, "utf-8");
+    const { result, applied, errors } = applyEditBlocks(content, blocks);
+
+    if (applied > 0) {
+      await fs.writeFile(fullPath, result, "utf-8");
+    }
+
+    // Generate simple diff
+    const diffLines: string[] = [`--- a/${filePath}`, `+++ b/${filePath}`];
+    for (const block of blocks.slice(0, applied)) {
+      diffLines.push(`-${block.search.split("\n")[0]}`);
+      diffLines.push(`+${block.replace.split("\n")[0]}`);
+    }
+
+    return {
+      filePath,
+      applied,
+      failed: blocks.length - applied,
+      errors,
+      diff: diffLines.join("\n"),
+    };
+  } catch (error) {
+    return {
+      filePath,
+      applied: 0,
+      failed: blocks.length,
+      errors: [`Failed to read file: ${error instanceof Error ? error.message : String(error)}`],
+      diff: "",
+    };
+  }
+}
+
+/**
+ * Generate edit block format for LLM
+ */
+export function formatEditBlock(search: string, replace: string): string {
+  return `<<<<<<< SEARCH\n${search}=======\n${replace}>>>>>>> REPLACE`;
+}
+
+/**
+ * EditBlock tool definition
+ */
+export const editBlockTool: ToolDefinition = {
+  name: "edit_block",
+  description: `Apply SEARCH/REPLACE edit blocks to a file. This is the most precise way to edit files.
+
+Format your edits as:
+<<<<<<< SEARCH
+exact text to find
+=======
+replacement text
+>>>>>>> REPLACE
+
+Multiple edit blocks can be applied in a single call. Each SEARCH block must match exactly once in the file.`,
+  parameters: {
+    path: { type: "string", description: "Path to the file to edit", required: true },
+    edits: { type: "string", description: "Edit blocks in SEARCH/REPLACE format", required: true },
+  },
+  category: "file",
+  requiresApproval: true,
+  handler: async (args, context): Promise<ToolResult> => {
+    const blocks = parseEditBlocks(args.edits as string);
+
+    if (blocks.length === 0) {
+      return {
+        success: false,
+        output: "",
+        error: "No valid edit blocks found. Use <<<<<<< SEARCH / ======= / >>>>>>> REPLACE format.",
+      };
+    }
+
+    const result = await applyEditBlocksToFile(args.path as string, blocks, context.workingDirectory);
+
+    return {
+      success: result.applied > 0,
+      output: `Applied ${result.applied}/${blocks.length} edit blocks to ${args.path}${result.errors.length > 0 ? "\nErrors:\n" + result.errors.join("\n") : ""}`,
+      data: result,
+      error: result.applied === 0 ? result.errors.join("; ") : undefined,
+    };
+  },
+};

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

@@ -0,0 +1,151 @@
+/**
+ * ZERO PubSub Events System
+ * Adapted from: crush (Charm) - MIT
+ *
+ * Event-driven pub/sub system for inter-component communication.
+ */
+
+export type EventHandler<T = unknown> = (data: T) => void | Promise<void>;
+
+export interface EventDefinition<T = unknown> {
+  type: string;
+  description?: string;
+}
+
+export class EventBus {
+  private handlers = new Map<string, Set<EventHandler>>();
+  private history: Array<{ type: string; data: unknown; timestamp: number }> = [];
+  private maxHistory = 100;
+
+  /**
+   * Subscribe to an event
+   */
+  on<T = unknown>(eventType: string, handler: EventHandler<T>): () => void {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, new Set());
+    }
+    this.handlers.get(eventType)!.add(handler as EventHandler);
+
+    // Return unsubscribe function
+    return () => {
+      this.handlers.get(eventType)?.delete(handler as EventHandler);
+    };
+  }
+
+  /**
+   * Subscribe to an event (one-time)
+   */
+  once<T = unknown>(eventType: string, handler: EventHandler<T>): () => void {
+    const wrappedHandler: EventHandler<T> = async (data) => {
+      unsubscribe();
+      await handler(data);
+    };
+    const unsubscribe = this.on(eventType, wrappedHandler);
+    return unsubscribe;
+  }
+
+  /**
+   * Emit an event
+   */
+  async emit<T = unknown>(eventType: string, data: T): Promise<void> {
+    // Add to history
+    this.history.push({ type: eventType, data, timestamp: Date.now() });
+    if (this.history.length > this.maxHistory) {
+      this.history.shift();
+    }
+
+    // Call handlers
+    const handlers = this.handlers.get(eventType);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          await handler(data);
+        } catch (error) {
+          console.error(`Error in event handler for ${eventType}:`, error);
+        }
+      }
+    }
+  }
+
+  /**
+   * Get event history
+   */
+  getHistory(eventType?: string): Array<{ type: string; data: unknown; timestamp: number }> {
+    if (eventType) {
+      return this.history.filter((e) => e.type === eventType);
+    }
+    return [...this.history];
+  }
+
+  /**
+   * Clear event history
+   */
+  clearHistory(): void {
+    this.history = [];
+  }
+
+  /**
+   * Remove all handlers for an event type
+   */
+  off(eventType: string): void {
+    this.handlers.delete(eventType);
+  }
+
+  /**
+   * Remove all handlers
+   */
+  removeAll(): void {
+    this.handlers.clear();
+  }
+}
+
+// ============================================================================
+// Pre-defined Event Types
+// ============================================================================
+
+export const ZERO_EVENTS = {
+  // Session events
+  SESSION_CREATED: "session:created",
+  SESSION_UPDATED: "session:updated",
+  SESSION_DELETED: "session:deleted",
+
+  // Agent events
+  AGENT_STARTED: "agent:started",
+  AGENT_COMPLETED: "agent:completed",
+  AGENT_ERROR: "agent:error",
+
+  // Tool events
+  TOOL_CALL_START: "tool:call:start",
+  TOOL_CALL_COMPLETE: "tool:call:complete",
+  TOOL_CALL_ERROR: "tool:call:error",
+
+  // Message events
+  MESSAGE_USER: "message:user",
+  MESSAGE_ASSISTANT: "message:assistant",
+  MESSAGE_SYSTEM: "message:system",
+
+  // Permission events
+  PERMISSION_REQUESTED: "permission:requested",
+  PERMISSION_GRANTED: "permission:granted",
+  PERMISSION_DENIED: "permission:denied",
+
+  // MCP events
+  MCP_CONNECTED: "mcp:connected",
+  MCP_DISCONNECTED: "mcp:disconnected",
+  MCP_ERROR: "mcp:error",
+
+  // Git events
+  GIT_COMMIT: "git:commit",
+  GIT_BRANCH: "git:branch",
+  GIT_MERGE: "git:merge",
+
+  // File events
+  FILE_CHANGED: "file:changed",
+  FILE_CREATED: "file:created",
+  FILE_DELETED: "file:deleted",
+} as const;
+
+/**
+ * Global event bus instance
+ */
+export const globalEventBus = new EventBus();