zero-ai-cli 1.0.0

package/packages/core/src/file-tracker/index.ts

@@ -0,0 +1,183 @@
+/**
+ * ZERO File Tracker Service
+ * Adapted from: crush (Charm) - MIT
+ *
+ * Tracks file changes and provides file system monitoring.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { watch, type FSWatcher } from "node:fs";
+import { globalEventBus, ZERO_EVENTS } from "../events/index.js";
+
+export interface FileChange {
+  path: string;
+  type: "created" | "modified" | "deleted";
+  timestamp: number;
+  size?: number;
+}
+
+export interface FileTrackerOptions {
+  workingDirectory: string;
+  ignorePatterns?: string[];
+  debounceMs?: number;
+}
+
+export class FileTracker {
+  private workingDirectory: string;
+  private ignorePatterns: RegExp[];
+  private debounceMs: number;
+  private watcher?: FSWatcher;
+  private changeHistory: FileChange[] = [];
+  private pendingChanges = new Map<string, NodeJS.Timeout>();
+  private fileHashes = new Map<string, string>();
+
+  constructor(options: FileTrackerOptions) {
+    this.workingDirectory = options.workingDirectory;
+    this.ignorePatterns = (options.ignorePatterns || [
+      "node_modules",
+      ".git",
+      "__pycache__",
+      "dist",
+      "build",
+      "coverage",
+      ".next",
+      ".nuxt",
+      "target",
+      "vendor",
+      ".venv",
+      "venv",
+      ".cache",
+      ".turbo",
+      "*.log",
+    ]).map((p) => new RegExp(p.replace(/\*/g, ".*")));
+    this.debounceMs = options.debounceMs || 100;
+  }
+
+  /**
+   * Start watching for file changes
+   */
+  async start(): Promise<void> {
+    // Initial scan
+    await this.scanDirectory(this.workingDirectory);
+
+    // Start watcher
+    this.watcher = watch(this.workingDirectory, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      const fullPath = path.join(this.workingDirectory, filename);
+
+      // Check ignore patterns
+      if (this.shouldIgnore(fullPath)) return;
+
+      // Debounce
+      const existing = this.pendingChanges.get(fullPath);
+      if (existing) clearTimeout(existing);
+
+      this.pendingChanges.set(
+        fullPath,
+        setTimeout(() => this.handleFileChange(fullPath), this.debounceMs)
+      );
+    });
+  }
+
+  /**
+   * Stop watching
+   */
+  stop(): void {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = undefined;
+    }
+
+    // Clear pending changes
+    for (const timeout of this.pendingChanges.values()) {
+      clearTimeout(timeout);
+    }
+    this.pendingChanges.clear();
+  }
+
+  /**
+   * Get change history
+   */
+  getHistory(limit?: number): FileChange[] {
+    const history = [...this.changeHistory].sort((a, b) => b.timestamp - a.timestamp);
+    return limit ? history.slice(0, limit) : history;
+  }
+
+  /**
+   * Clear history
+   */
+  clearHistory(): void {
+    this.changeHistory = [];
+  }
+
+  /**
+   * Get recently changed files
+   */
+  getRecentChanges(sinceMs: number): FileChange[] {
+    const cutoff = Date.now() - sinceMs;
+    return this.changeHistory.filter((c) => c.timestamp > cutoff);
+  }
+
+  private shouldIgnore(filePath: string): boolean {
+    const relativePath = path.relative(this.workingDirectory, filePath);
+    return this.ignorePatterns.some((pattern) => pattern.test(relativePath));
+  }
+
+  private async handleFileChange(filePath: string): Promise<void> {
+    this.pendingChanges.delete(filePath);
+
+    try {
+      const stats = await fs.stat(filePath);
+      const change: FileChange = {
+        path: path.relative(this.workingDirectory, filePath),
+        type: "modified",
+        timestamp: Date.now(),
+        size: stats.size,
+      };
+
+      if (!this.fileHashes.has(filePath)) {
+        change.type = "created";
+      }
+
+      this.fileHashes.set(filePath, `${stats.size}-${stats.mtimeMs}`);
+      this.changeHistory.push(change);
+
+      // Emit event
+      await globalEventBus.emit(ZERO_EVENTS.FILE_CHANGED, change);
+    } catch (error) {
+      // File was deleted
+      if (this.fileHashes.has(filePath)) {
+        const change: FileChange = {
+          path: path.relative(this.workingDirectory, filePath),
+          type: "deleted",
+          timestamp: Date.now(),
+        };
+        this.fileHashes.delete(filePath);
+        this.changeHistory.push(change);
+        await globalEventBus.emit(ZERO_EVENTS.FILE_DELETED, change);
+      }
+    }
+  }
+
+  private async scanDirectory(dir: string): Promise<void> {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        if (this.shouldIgnore(fullPath)) continue;
+
+        if (entry.isDirectory()) {
+          await this.scanDirectory(fullPath);
+        } else if (entry.isFile()) {
+          try {
+            const stats = await fs.stat(fullPath);
+            this.fileHashes.set(fullPath, `${stats.size}-${stats.mtimeMs}`);
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+}

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

@@ -0,0 +1,305 @@
+/**
+ * ZERO Git Service
+ * Adapted from: opencode (SST) - MIT
+ *
+ * Comprehensive git integration with support for status, diff,
+ * patches, branching, and merge operations.
+ */
+
+import { execSync } from "node:child_process";
+
+const GIT_CONFIG_ARGS = [
+  "--no-optional-locks",
+  "-c", "core.autocrlf=false",
+  "-c", "core.fsmonitor=false",
+  "-c", "core.longpaths=true",
+  "-c", "core.symlinks=true",
+  "-c", "core.quotepath=false",
+] as const;
+
+export type ChangeKind = "added" | "deleted" | "modified";
+
+export interface GitItem {
+  readonly file: string;
+  readonly code: string;
+  readonly status: ChangeKind;
+}
+
+export interface GitStat {
+  readonly file: string;
+  readonly additions: number;
+  readonly deletions: number;
+}
+
+export interface GitPatch {
+  readonly text: string;
+  readonly truncated: boolean;
+}
+
+export interface GitBase {
+  readonly name: string;
+  readonly ref: string;
+}
+
+export interface PatchOptions {
+  readonly context?: number;
+  readonly maxOutputBytes?: number;
+}
+
+export interface GitResult {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly truncated: boolean;
+}
+
+export class GitService {
+  constructor(private cwd: string) {}
+
+  // ========================================================================
+  // Core Operations
+  // ========================================================================
+
+  private run(args: string[], options?: { stdin?: string; maxOutputBytes?: number }): GitResult {
+    try {
+      const fullArgs = [...GIT_CONFIG_ARGS, ...args];
+      const stdout = execSync(`git ${fullArgs.join(" ")}`, {
+        cwd: this.cwd,
+        encoding: "utf-8",
+        maxBuffer: options?.maxOutputBytes || 10 * 1024 * 1024,
+        input: options?.stdin,
+        timeout: 30000,
+      });
+
+      return {
+        exitCode: 0,
+        stdout: stdout.trim(),
+        stderr: "",
+        truncated: false,
+      };
+    } catch (error: any) {
+      return {
+        exitCode: error.status || 1,
+        stdout: (error.stdout || "").trim(),
+        stderr: (error.stderr || error.message || "").trim(),
+        truncated: false,
+      };
+    }
+  }
+
+  // ========================================================================
+  // Branch Operations
+  // ========================================================================
+
+  branch(): string | undefined {
+    const result = this.run(["rev-parse", "--abbrev-ref", "HEAD"]);
+    return result.exitCode === 0 ? result.stdout : undefined;
+  }
+
+  defaultBranch(): GitBase | undefined {
+    // Try common default branch names
+    for (const name of ["main", "master", "develop"]) {
+      const result = this.run(["rev-parse", "--verify", `refs/heads/${name}`]);
+      if (result.exitCode === 0) {
+        return { name, ref: result.stdout };
+      }
+    }
+
+    // Fall back to git config
+    const result = this.run(["config", "init.defaultBranch"]);
+    if (result.exitCode === 0 && result.stdout) {
+      const refResult = this.run(["rev-parse", "--verify", `refs/heads/${result.stdout}`]);
+      if (refResult.exitCode === 0) {
+        return { name: result.stdout, ref: refResult.stdout };
+      }
+    }
+
+    return undefined;
+  }
+
+  hasHead(): boolean {
+    return this.run(["rev-parse", "HEAD"]).exitCode === 0;
+  }
+
+  mergeBase(base: string, head?: string): string | undefined {
+    const args = ["merge-base", base];
+    if (head) args.push(head);
+    const result = this.run(args);
+    return result.exitCode === 0 ? result.stdout : undefined;
+  }
+
+  // ========================================================================
+  // Status & Diff
+  // ========================================================================
+
+  status(): GitItem[] {
+    const result = this.run(["status", "--porcelain=v1", "-z"]);
+    if (result.exitCode !== 0) return [];
+
+    const kind = (code: string): ChangeKind => {
+      if (code === "??") return "added";
+      if (code.includes("U")) return "modified";
+      if (code.includes("A") && !code.includes("D")) return "added";
+      if (code.includes("D") && !code.includes("A")) return "deleted";
+      return "modified";
+    };
+
+    const entries = result.stdout.split("\0").filter(Boolean);
+    const items: GitItem[] = [];
+
+    for (const entry of entries) {
+      if (entry.length < 4) continue;
+      const code = entry.slice(0, 2).trim();
+      const file = entry.slice(3);
+      items.push({ file, code, status: kind(code) });
+    }
+
+    return items;
+  }
+
+  diff(ref: string): GitItem[] {
+    const result = this.run(["diff", "--name-status", "-z", ref]);
+    if (result.exitCode !== 0) return [];
+
+    const parts = result.stdout.split("\0").filter(Boolean);
+    const items: GitItem[] = [];
+
+    for (let i = 0; i < parts.length; i += 2) {
+      const code = parts[i]?.trim();
+      const file = parts[i + 1];
+      if (!code || !file) continue;
+
+      const status: ChangeKind = code.startsWith("A") ? "added"
+        : code.startsWith("D") ? "deleted"
+        : "modified";
+
+      items.push({ file, code, status });
+    }
+
+    return items;
+  }
+
+  stats(ref: string): GitStat[] {
+    const result = this.run(["diff", "--numstat", ref]);
+    if (result.exitCode !== 0) return [];
+
+    return result.stdout.split("\n")
+      .filter(Boolean)
+      .map((line) => {
+        const [additions, deletions, file] = line.split("\t");
+        return {
+          file: file || "",
+          additions: parseInt(additions) || 0,
+          deletions: parseInt(deletions) || 0,
+        };
+      });
+  }
+
+  // ========================================================================
+  // Patch Operations
+  // ========================================================================
+
+  patch(ref: string, file: string, options?: PatchOptions): GitPatch {
+    const context = options?.context ?? 3;
+    const args = ["diff", `--unified=${context}`, ref, "--", file];
+    const result = this.run(args, { maxOutputBytes: options?.maxOutputBytes });
+
+    return {
+      text: result.stdout,
+      truncated: result.truncated,
+    };
+  }
+
+  patchAll(ref: string, options?: PatchOptions): GitPatch {
+    const context = options?.context ?? 3;
+    const args = ["diff", `--unified=${context}`, ref];
+    const result = this.run(args, { maxOutputBytes: options?.maxOutputBytes });
+
+    return {
+      text: result.stdout,
+      truncated: result.truncated,
+    };
+  }
+
+  patchUntracked(file: string, options?: PatchOptions): GitPatch {
+    // For untracked files, show the entire content as additions
+    const result = this.run(["diff", "--no-index", "/dev/null", file], {
+      maxOutputBytes: options?.maxOutputBytes,
+    });
+
+    return {
+      text: result.stdout || result.stderr,
+      truncated: result.truncated,
+    };
+  }
+
+  applyPatch(patch: string): GitResult {
+    return this.run(["apply", "--allow-empty", "-"], { stdin: patch });
+  }
+
+  // ========================================================================
+  // Show & Log
+  // ========================================================================
+
+  show(ref: string, file: string): string {
+    const result = this.run(["show", `${ref}:${file}`]);
+    return result.exitCode === 0 ? result.stdout : "";
+  }
+
+  log(options?: { maxCount?: number; ref?: string }): Array<{ hash: string; message: string; date: string }> {
+    const maxCount = options?.maxCount || 10;
+    const args = ["log", `--max-count=${maxCount}`, "--format=%H|%s|%aI"];
+    if (options?.ref) args.push(options.ref);
+
+    const result = this.run(args);
+    if (result.exitCode !== 0) return [];
+
+    return result.stdout.split("\n")
+      .filter(Boolean)
+      .map((line) => {
+        const [hash, message, date] = line.split("|");
+        return { hash, message, date };
+      });
+  }
+
+  // ========================================================================
+  // Commit Operations
+  // ========================================================================
+
+  add(files: string[] | "."): GitResult {
+    const args = ["add"];
+    if (files === ".") {
+      args.push("-A");
+    } else {
+      args.push("--", ...files);
+    }
+    return this.run(args);
+  }
+
+  commit(message: string, options?: { amend?: boolean; noVerify?: boolean }): GitResult {
+    const args = ["commit", "-m", message];
+    if (options?.amend) args.push("--amend");
+    if (options?.noVerify) args.push("--no-verify");
+    return this.run(args);
+  }
+
+  // ========================================================================
+  // Stash Operations
+  // ========================================================================
+
+  stash(options?: { message?: string }): GitResult {
+    const args = ["stash", "push"];
+    if (options?.message) args.push("-m", options.message);
+    return this.run(args);
+  }
+
+  stashPop(): GitResult {
+    return this.run(["stash", "pop"]);
+  }
+
+  stashList(): string[] {
+    const result = this.run(["stash", "list"]);
+    if (result.exitCode !== 0) return [];
+    return result.stdout.split("\n").filter(Boolean);
+  }
+}