@c4ccz/zero 1.0.0 → 1.0.1

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

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