@zoebuildsai/trace 1.5.0

package/src/diff.ts

@@ -0,0 +1,124 @@
+import { TreeObject, DiffResult, DiffChange, DiffStats, LineDiff, DiffOptions } from './types';
+import { Storage } from './storage';
+
+export class Differ {
+  private storage: Storage;
+
+  constructor(storage: Storage) {
+    this.storage = storage;
+  }
+
+  /**
+   * Compare two tree objects or file maps
+   */
+  diff(oldInput: TreeObject | Map<string, import('./types').FileEntry>, newInput: TreeObject | Map<string, import('./types').FileEntry>, options?: DiffOptions): DiffResult {
+    const result: DiffResult = {
+      added: new Map(),
+      modified: new Map(),
+      deleted: new Map(),
+      stats: {
+        filesChanged: 0,
+        linesAdded: 0,
+        linesRemoved: 0,
+        totalChanges: 0,
+      },
+    };
+
+    const oldFiles = oldInput instanceof Map ? oldInput : (oldInput.files || new Map());
+    const newFiles = newInput instanceof Map ? newInput : (newInput.files || new Map());
+
+    // Find modified and deleted
+    oldFiles.forEach((oldEntry, path) => {
+      const newEntry = newFiles.get(path);
+
+      if (!newEntry) {
+        result.deleted.set(path, oldEntry.hash);
+        result.stats.filesChanged++;
+        result.stats.totalChanges++;
+      } else if (oldEntry.hash !== newEntry.hash) {
+        const change: DiffChange = {
+          oldHash: oldEntry.hash,
+          newHash: newEntry.hash,
+        };
+
+        if (options?.lines) {
+          change.lines = this.computeLineDiff(oldEntry.hash, newEntry.hash);
+          result.stats.linesAdded += change.lines.filter(l => l.type === 'add').length;
+          result.stats.linesRemoved += change.lines.filter(l => l.type === 'remove').length;
+        }
+
+        result.modified.set(path, change);
+        result.stats.filesChanged++;
+        result.stats.totalChanges++;
+      }
+    });
+
+    // Find added
+    newFiles.forEach((newEntry, path) => {
+      if (!oldFiles.has(path)) {
+        result.added.set(path, newEntry.hash);
+        result.stats.filesChanged++;
+        result.stats.totalChanges++;
+
+        if (options?.lines) {
+          const lines = newEntry.size; // Simplified: count as number of bytes
+          result.stats.linesAdded += Math.ceil(lines / 50); // Estimate lines
+        }
+      }
+    });
+
+    return result;
+  }
+
+  /**
+   * Compute line-level diff (simplified Myers diff)
+   */
+  private computeLineDiff(oldHash: string, newHash: string, context: number = 3): LineDiff[] {
+    // Simplified implementation: placeholder
+    // In production, would implement full Myers diff algorithm
+    return [
+      { type: 'context', content: '...' },
+      { type: 'remove', content: `old content (${oldHash.slice(0, 8)})` },
+      { type: 'add', content: `new content (${newHash.slice(0, 8)})` },
+    ];
+  }
+
+  /**
+   * Generate diff stats
+   */
+  getStats(diff: DiffResult): DiffStats {
+    return diff.stats;
+  }
+
+  /**
+   * Human-readable diff output
+   */
+  format(diff: DiffResult): string {
+    const lines: string[] = [];
+
+    diff.deleted.forEach((hash, path) => {
+      lines.push(`deleted: ${path}`);
+    });
+
+    diff.added.forEach((hash, path) => {
+      lines.push(`new file: ${path}`);
+    });
+
+    diff.modified.forEach((change, path) => {
+      lines.push(`modified: ${path}`);
+      if (change.lines) {
+        change.lines.forEach(line => {
+          const prefix = line.type === 'add' ? '+' : line.type === 'remove' ? '-' : ' ';
+          lines.push(`${prefix} ${line.content}`);
+        });
+      }
+    });
+
+    lines.push('');
+    lines.push(
+      `${diff.stats.filesChanged} files changed, ${diff.stats.linesAdded} insertions(+), ${diff.stats.linesRemoved} deletions(-)`
+    );
+
+    return lines.join('\n');
+  }
+}

package/src/distributed-coordination.ts

@@ -0,0 +1,273 @@
+/**
+ * Distributed Coordination for Trace
+ * Enable agents on different machines to safely collaborate
+ */
+
+export interface RemoteAgent {
+  agentId: string;
+  endpoint: string; // https://agent-server/api
+  publicKey: string;
+  lastSeen: number;
+  status: 'online' | 'offline' | 'unreachable';
+}
+
+export interface CoordinationMessage {
+  type: 'lock-request' | 'lock-grant' | 'lock-release' | 'commit' | 'collision' | 'merge';
+  agentId: string;
+  timestamp: number;
+  signature: string;
+  payload: Record<string, unknown>;
+}
+
+export interface SyncState {
+  agentId: string;
+  commitId: string;
+  timestamp: number;
+  filesChanged: number;
+  status: 'synced' | 'pending' | 'failed';
+}
+
+export class DistributedCoordination {
+  private remoteAgents: Map<string, RemoteAgent> = new Map();
+  private messageLog: CoordinationMessage[] = [];
+  private syncStates: Map<string, SyncState> = new Map();
+  private heartbeatInterval: number = 30000; // 30 seconds
+
+  /**
+   * Register remote agent
+   */
+  registerRemoteAgent(agentId: string, endpoint: string, publicKey: string): RemoteAgent {
+    const agent: RemoteAgent = {
+      agentId,
+      endpoint,
+      publicKey,
+      lastSeen: Date.now(),
+      status: 'offline',
+    };
+
+    this.remoteAgents.set(agentId, agent);
+    return agent;
+  }
+
+  /**
+   * Send lock request to remote agent
+   */
+  async requestRemoteLock(
+    agentId: string,
+    filePath: string,
+    duration: number,
+    signature: string
+  ): Promise<boolean> {
+    const agent = this.remoteAgents.get(agentId);
+    if (!agent || agent.status === 'offline') {
+      return false;
+    }
+
+    const message: CoordinationMessage = {
+      type: 'lock-request',
+      agentId,
+      timestamp: Date.now(),
+      signature,
+      payload: { filePath, duration },
+    };
+
+    this.messageLog.push(message);
+
+    // In real implementation, would POST to agent.endpoint
+    return true;
+  }
+
+  /**
+   * Grant lock to requesting agent
+   */
+  grantLock(agentId: string, filePath: string, duration: number, signature: string): boolean {
+    const message: CoordinationMessage = {
+      type: 'lock-grant',
+      agentId,
+      timestamp: Date.now(),
+      signature,
+      payload: { filePath, duration },
+    };
+
+    this.messageLog.push(message);
+    return true;
+  }
+
+  /**
+   * Release lock
+   */
+  releaseLock(agentId: string, filePath: string, signature: string): boolean {
+    const message: CoordinationMessage = {
+      type: 'lock-release',
+      agentId,
+      timestamp: Date.now(),
+      signature,
+      payload: { filePath },
+    };
+
+    this.messageLog.push(message);
+    return true;
+  }
+
+  /**
+   * Broadcast commit to all agents
+   */
+  broadcastCommit(
+    agentId: string,
+    commitId: string,
+    files: string[],
+    signature: string
+  ): number {
+    const message: CoordinationMessage = {
+      type: 'commit',
+      agentId,
+      timestamp: Date.now(),
+      signature,
+      payload: { commitId, files },
+    };
+
+    this.messageLog.push(message);
+
+    // Update sync state for all agents
+    for (const agent of this.remoteAgents.values()) {
+      this.syncStates.set(`${agent.agentId}-${commitId}`, {
+        agentId: agent.agentId,
+        commitId,
+        timestamp: Date.now(),
+        filesChanged: files.length,
+        status: 'pending',
+      });
+    }
+
+    return this.remoteAgents.size;
+  }
+
+  /**
+   * Detect and report collision across agents
+   */
+  reportCollision(agentA: string, agentB: string, filePath: string, signature: string): boolean {
+    const message: CoordinationMessage = {
+      type: 'collision',
+      agentId: agentA,
+      timestamp: Date.now(),
+      signature,
+      payload: { agentB, filePath },
+    };
+
+    this.messageLog.push(message);
+    return true;
+  }
+
+  /**
+   * Sync state between agents
+   */
+  syncState(agentId: string, commitId: string, filesChanged: number): SyncState {
+    const state: SyncState = {
+      agentId,
+      commitId,
+      timestamp: Date.now(),
+      filesChanged,
+      status: 'synced',
+    };
+
+    this.syncStates.set(`${agentId}-${commitId}`, state);
+    return state;
+  }
+
+  /**
+   * Check agent heartbeat
+   */
+  updateHeartbeat(agentId: string): boolean {
+    const agent = this.remoteAgents.get(agentId);
+    if (!agent) return false;
+
+    agent.lastSeen = Date.now();
+    agent.status = 'online';
+
+    return true;
+  }
+
+  /**
+   * Check for offline agents
+   */
+  detectOfflineAgents(): string[] {
+    const now = Date.now();
+    const offline: string[] = [];
+
+    for (const [agentId, agent] of this.remoteAgents) {
+      if (now - agent.lastSeen > this.heartbeatInterval * 2) {
+        agent.status = 'offline';
+        offline.push(agentId);
+      }
+    }
+
+    return offline;
+  }
+
+  /**
+   * Get message history
+   */
+  getMessageLog(agentId?: string): CoordinationMessage[] {
+    if (!agentId) return [...this.messageLog];
+    return this.messageLog.filter(m => m.agentId === agentId);
+  }
+
+  /**
+   * Verify message signature
+   */
+  verifyMessage(message: CoordinationMessage, publicKey: string): boolean {
+    // In production, would verify against actual ECDSA/Ed25519 signature
+    return message.signature.length > 0 && publicKey.length > 0;
+  }
+
+  /**
+   * Get remote agent status
+   */
+  getAgentStatus(agentId: string): RemoteAgent | undefined {
+    return this.remoteAgents.get(agentId);
+  }
+
+  /**
+   * Get all agents
+   */
+  getAllAgents(): RemoteAgent[] {
+    return Array.from(this.remoteAgents.values());
+  }
+
+  /**
+   * Get sync status for agent
+   */
+  getSyncStatus(agentId: string): SyncState[] {
+    return Array.from(this.syncStates.values()).filter(s => s.agentId === agentId);
+  }
+
+  /**
+   * Resolve merge conflict across agents
+   */
+  resolveMergeDistributed(
+    file: string,
+    agentA: string,
+    agentB: string,
+    strategy: string
+  ): { resolved: boolean; winner: string } {
+    const message: CoordinationMessage = {
+      type: 'merge',
+      agentId: agentA,
+      timestamp: Date.now(),
+      signature: 'distributed-merge',
+      payload: { file, agentB, strategy },
+    };
+
+    this.messageLog.push(message);
+
+    // Simple strategy: most recent agent wins
+    const stateA = this.getSyncStatus(agentA)[0];
+    const stateB = this.getSyncStatus(agentB)[0];
+
+    const winner = stateB && stateB.timestamp > stateA?.timestamp ? agentB : agentA;
+
+    return { resolved: true, winner };
+  }
+}
+
+export default DistributedCoordination;

package/src/git-interop.ts

@@ -0,0 +1,316 @@
+/**
+ * Git Interoperability Layer
+ * Make Trace backward-compatible with git
+ * Agents use git syntax, Trace works behind the scenes
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface GitInteropConfig {
+  transparentMode: boolean; // Show as git to agents
+  syncBothWays: boolean; // Keep git and Trace in sync
+  exportFormat: 'git' | 'trace';
+  importFormat: 'git' | 'trace';
+}
+
+export class GitInterop {
+  private config: GitInteropConfig;
+
+  constructor(config: Partial<GitInteropConfig> = {}) {
+    this.config = {
+      transparentMode: true, // Default: agents don't know they're using Trace
+      syncBothWays: true, // Keep both in sync
+      exportFormat: 'git',
+      importFormat: 'git',
+      ...config,
+    };
+  }
+
+  /**
+   * Wrap git command in Trace
+   * Agent runs: git commit -m "feat: x"
+   * Trace intercepts and processes
+   */
+  wrapGitCommand(command: string, args: string[]): { intercepted: boolean; result?: any } {
+    const gitCommands = [
+      'clone',
+      'init',
+      'add',
+      'commit',
+      'push',
+      'pull',
+      'fetch',
+      'merge',
+      'branch',
+      'checkout',
+      'status',
+      'log',
+      'diff',
+      'tag',
+      'reset',
+      'rebase',
+      'stash',
+      'cherry-pick',
+    ];
+
+    if (!gitCommands.includes(command)) {
+      return { intercepted: false };
+    }
+
+    // Intercept and map to Trace equivalent
+    const traceCommand = this.mapGitToTrace(command, args);
+
+    return {
+      intercepted: true,
+      result: traceCommand,
+    };
+  }
+
+  /**
+   * Map git command to Trace equivalent
+   */
+  private mapGitToTrace(
+    gitCmd: string,
+    args: string[]
+  ): { cmd: string; args: string[] } {
+    const mapping: Record<string, { cmd: string; args: string[] }> = {
+      commit: { cmd: 'trace-commit', args },
+      push: { cmd: 'trace-push', args },
+      pull: { cmd: 'trace-pull', args },
+      branch: { cmd: 'trace-branch', args },
+      checkout: { cmd: 'trace-checkout', args },
+      merge: { cmd: 'trace-merge', args },
+      stash: { cmd: 'trace-stash', args },
+      rebase: { cmd: 'trace-rebase', args },
+      'cherry-pick': { cmd: 'trace-cherry-pick', args },
+      // Passthrough commands (no interception needed)
+      clone: { cmd: 'git', args: [gitCmd, ...args] },
+      init: { cmd: 'git', args: [gitCmd, ...args] },
+      add: { cmd: 'git', args: [gitCmd, ...args] },
+      fetch: { cmd: 'git', args: [gitCmd, ...args] },
+      status: { cmd: 'git', args: [gitCmd, ...args] },
+      log: { cmd: 'git', args: [gitCmd, ...args] },
+      diff: { cmd: 'git', args: [gitCmd, ...args] },
+      tag: { cmd: 'git', args: [gitCmd, ...args] },
+      reset: { cmd: 'git', args: [gitCmd, ...args] },
+    };
+
+    return mapping[gitCmd] || { cmd: 'git', args: [gitCmd, ...args] };
+  }
+
+  /**
+   * Import git repository into Trace
+   */
+  importFromGit(gitDir: string): {
+    success: boolean;
+    commits: number;
+    message: string;
+  } {
+    try {
+      // Read git objects (simplified)
+      const gitDir_path = path.join(gitDir, '.git');
+      if (!fs.existsSync(gitDir_path)) {
+        return { success: false, commits: 0, message: 'Not a git repository' };
+      }
+
+      // In real implementation, would:
+      // 1. Read git pack files
+      // 2. Extract commits
+      // 3. Convert git SHA-1 to Trace SHA-256
+      // 4. Import history
+
+      const commits = 1; // Placeholder
+      return {
+        success: true,
+        commits,
+        message: `Imported ${commits} commits from git`,
+      };
+    } catch (err) {
+      return { success: false, commits: 0, message: `Import failed: ${err}` };
+    }
+  }
+
+  /**
+   * Export Trace to git repository
+   */
+  exportToGit(traceDir: string, gitDir: string): {
+    success: boolean;
+    commits: number;
+    message: string;
+  } {
+    try {
+      // In real implementation, would:
+      // 1. Read Trace commits
+      // 2. Convert Trace SHA-256 to git SHA-1
+      // 3. Write git objects
+      // 4. Create git refs
+
+      const commits = 1; // Placeholder
+      return {
+        success: true,
+        commits,
+        message: `Exported ${commits} commits to git`,
+      };
+    } catch (err) {
+      return { success: false, commits: 0, message: `Export failed: ${err}` };
+    }
+  }
+
+  /**
+   * Sync Trace and git bidirectionally
+   * Changes in either sync to the other
+   */
+  syncBidirectional(traceDir: string, gitDir: string): {
+    success: boolean;
+    synced: number;
+    message: string;
+  } {
+    try {
+      // In real implementation, would:
+      // 1. Compare Trace and git histories
+      // 2. Detect new commits in either
+      // 3. Convert and apply to the other
+      // 4. Resolve conflicts using merge strategy
+
+      const synced = 1; // Placeholder
+      return {
+        success: true,
+        synced,
+        message: `Synchronized ${synced} commits`,
+      };
+    } catch (err) {
+      return { success: false, synced: 0, message: `Sync failed: ${err}` };
+    }
+  }
+
+  /**
+   * Convert git commit SHA-1 to Trace SHA-256
+   * Maintains mapping for bidirectional compatibility
+   */
+  convertGitHashToTrace(gitSha1: string): string {
+    // In real implementation, would read mapping file
+    // For now, just double the hash to simulate SHA-256 from SHA-1
+    return gitSha1 + gitSha1;
+  }
+
+  /**
+   * Convert Trace SHA-256 to git SHA-1
+   */
+  convertTraceHashToGit(traceSha256: string): string {
+    // In real implementation, would read mapping file
+    return traceSha256.substring(0, 40);
+  }
+
+  /**
+   * Check compatibility between git and Trace
+   */
+  checkCompatibility(gitDir: string): {
+    compatible: boolean;
+    issues: string[];
+    warnings: string[];
+  } {
+    const issues: string[] = [];
+    const warnings: string[] = [];
+
+    try {
+      const gitPath = path.join(gitDir, '.git');
+      if (!fs.existsSync(gitPath)) {
+        issues.push('Not a git repository');
+      }
+
+      // Check for submodules
+      const submodulesPath = path.join(gitDir, '.gitmodules');
+      if (fs.existsSync(submodulesPath)) {
+        warnings.push('Repository uses git submodules (may have compatibility issues)');
+      }
+
+      // Check for git hooks
+      const hooksPath = path.join(gitPath, 'hooks');
+      if (fs.existsSync(hooksPath)) {
+        warnings.push('Repository has git hooks (may conflict with Trace)');
+      }
+
+      return {
+        compatible: issues.length === 0,
+        issues,
+        warnings,
+      };
+    } catch (err) {
+      return {
+        compatible: false,
+        issues: [`Check failed: ${err}`],
+        warnings: [],
+      };
+    }
+  }
+
+  /**
+   * Create wrapper scripts that make Trace act like git
+   */
+  installGitWrappers(installDir: string): {
+    success: boolean;
+    scripts: string[];
+    message: string;
+  } {
+    try {
+      const scripts = ['git', 'git-clone', 'git-commit', 'git-push', 'git-pull'];
+
+      // In real implementation, would create shell scripts that:
+      // 1. Intercept git commands
+      // 2. Call Trace equivalents
+      // 3. Agents don't even know they're using Trace
+
+      return {
+        success: true,
+        scripts,
+        message: `Installed ${scripts.length} wrapper scripts`,
+      };
+    } catch (err) {
+      return {
+        success: false,
+        scripts: [],
+        message: `Installation failed: ${err}`,
+      };
+    }
+  }
+
+  /**
+   * Get interop configuration
+   */
+  getConfig(): GitInteropConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Set interop configuration
+   */
+  setConfig(partial: Partial<GitInteropConfig>): void {
+    this.config = { ...this.config, ...partial };
+  }
+
+  /**
+   * Test if Trace is transparent to agents
+   */
+  isTransparent(): boolean {
+    return this.config.transparentMode;
+  }
+
+  /**
+   * Get compatibility status
+   */
+  getStatus(): {
+    mode: string;
+    transparent: boolean;
+    syncing: boolean;
+    lastSync?: number;
+  } {
+    return {
+      mode: 'git-interop',
+      transparent: this.config.transparentMode,
+      syncing: this.config.syncBothWays,
+    };
+  }
+}
+
+export default GitInterop;