@c4ccz/zero 1.0.0 → 1.0.1

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();

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