@zoebuildsai/trace 1.5.0

package/src/commit-hash-system.ts

@@ -0,0 +1,351 @@
+/**
+ * Commit Hash System for Trace
+ * Git-like hashing for agent checkout capability
+ * Each commit is uniquely addressable by SHA-256 hash
+ */
+
+import * as crypto from 'crypto';
+
+export interface CommitHash {
+  full: string; // Full SHA-256 hash
+  short: string; // First 7 characters (like git)
+  commitId: string; // Unique identifier
+}
+
+export interface Commit {
+  hash: CommitHash;
+  parent?: string; // Parent commit hash
+  author: string; // Agent ID
+  message: string;
+  timestamp: number;
+  files: Map<string, string>; // filename -> content hash
+  signature: string; // Agent signature
+}
+
+export interface CommitIndex {
+  hash: string;
+  parent?: string;
+  author: string;
+  message: string;
+  timestamp: number;
+  fileCount: number;
+}
+
+export class CommitHashSystem {
+  private commits: Map<string, Commit> = new Map();
+  private hashIndex: Map<string, CommitIndex> = new Map();
+  private parentChild: Map<string, string[]> = new Map(); // parent -> [children]
+  private authCommits: Map<string, string[]> = new Map(); // author -> [commits]
+
+  /**
+   * Create commit hash from content
+   */
+  static createHash(
+    author: string,
+    message: string,
+    files: Map<string, string>,
+    parent?: string
+  ): CommitHash {
+    // Git-like hash: tree + parent + author + message + timestamp
+    const content = [
+      author,
+      message,
+      parent || 'root',
+      Array.from(files.entries())
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([f, h]) => `${f}:${h}`)
+        .join('|'),
+      Date.now().toString(),
+    ].join('\n');
+
+    const full = crypto.createHash('sha256').update(content).digest('hex');
+    const short = full.substring(0, 7);
+
+    return {
+      full,
+      short,
+      commitId: short,
+    };
+  }
+
+  /**
+   * Record commit in system
+   */
+  recordCommit(
+    author: string,
+    message: string,
+    files: Map<string, string>,
+    signature: string,
+    parent?: string
+  ): CommitHash {
+    const hash = CommitHashSystem.createHash(author, message, files, parent);
+
+    const commit: Commit = {
+      hash,
+      parent,
+      author,
+      message,
+      timestamp: Date.now(),
+      files: new Map(files),
+      signature,
+    };
+
+    this.commits.set(hash.full, commit);
+
+    // Index for fast lookup
+    this.hashIndex.set(hash.full, {
+      hash: hash.full,
+      parent,
+      author,
+      message,
+      timestamp: commit.timestamp,
+      fileCount: files.size,
+    });
+
+    // Parent-child tracking
+    if (parent) {
+      if (!this.parentChild.has(parent)) {
+        this.parentChild.set(parent, []);
+      }
+      this.parentChild.get(parent)!.push(hash.full);
+    }
+
+    // Author tracking
+    if (!this.authCommits.has(author)) {
+      this.authCommits.set(author, []);
+    }
+    this.authCommits.get(author)!.push(hash.full);
+
+    return hash;
+  }
+
+  /**
+   * Get commit by hash (full or short)
+   */
+  getCommit(hash: string): Commit | undefined {
+    // Try full hash first
+    if (this.commits.has(hash)) {
+      return this.commits.get(hash);
+    }
+
+    // Try short hash
+    for (const [fullHash, commit] of this.commits) {
+      if (fullHash.startsWith(hash)) {
+        return commit;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Get commit index (lightweight lookup)
+   */
+  getCommitIndex(hash: string): CommitIndex | undefined {
+    if (this.hashIndex.has(hash)) {
+      return this.hashIndex.get(hash);
+    }
+
+    // Try short hash
+    for (const [fullHash, index] of this.hashIndex) {
+      if (fullHash.startsWith(hash)) {
+        return index;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Resolve short hash to full hash
+   */
+  resolveHash(shortHash: string): string | undefined {
+    for (const fullHash of this.commits.keys()) {
+      if (fullHash.startsWith(shortHash)) {
+        return fullHash;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Get commit chain (ancestry)
+   */
+  getChain(hash: string): Commit[] {
+    const chain: Commit[] = [];
+    let current = this.getCommit(hash);
+
+    while (current) {
+      chain.push(current);
+      if (current.parent) {
+        current = this.getCommit(current.parent);
+      } else {
+        break;
+      }
+    }
+
+    return chain;
+  }
+
+  /**
+   * Get children of commit (for branching)
+   */
+  getChildren(hash: string): Commit[] {
+    const fullHash = this.resolveHash(hash) || hash;
+    const childHashes = this.parentChild.get(fullHash) || [];
+    return childHashes
+      .map(h => this.getCommit(h))
+      .filter((c): c is Commit => c !== undefined);
+  }
+
+  /**
+   * Get all commits by author
+   */
+  getCommitsByAuthor(author: string): Commit[] {
+    const hashes = this.authCommits.get(author) || [];
+    return hashes
+      .map(h => this.getCommit(h))
+      .filter((c): c is Commit => c !== undefined);
+  }
+
+  /**
+   * Verify commit integrity
+   */
+  verifyCommit(hash: string, expectedSignature: string): boolean {
+    const commit = this.getCommit(hash);
+    if (!commit) return false;
+
+    // Verify hash matches content
+    const recomputed = CommitHashSystem.createHash(
+      commit.author,
+      commit.message,
+      commit.files,
+      commit.parent
+    );
+
+    return recomputed.full === (this.resolveHash(hash) || hash) && commit.signature === expectedSignature;
+  }
+
+  /**
+   * Check if commit is ancestor of another
+   */
+  isAncestor(potentialAncestor: string, commit: string): boolean {
+    const chain = this.getChain(commit);
+    const ancestorFullHash = this.resolveHash(potentialAncestor) || potentialAncestor;
+    return chain.some(c => c.hash.full === ancestorFullHash);
+  }
+
+  /**
+   * Get commit range (for diff, log, etc)
+   */
+  getRange(fromHash: string, toHash: string): Commit[] {
+    const fromChain = this.getChain(fromHash);
+    const toChain = this.getChain(toHash);
+
+    // Find common ancestor
+    const toSet = new Set(toChain.map(c => c.hash.full));
+    let commonAncestor = null;
+    for (const commit of fromChain) {
+      if (toSet.has(commit.hash.full)) {
+        commonAncestor = commit.hash.full;
+        break;
+      }
+    }
+
+    if (!commonAncestor) return [];
+
+    // Get commits from commonAncestor to toHash
+    const result: Commit[] = [];
+    let current = this.getCommit(toHash);
+    while (current && current.hash.full !== commonAncestor) {
+      result.push(current);
+      current = current.parent ? this.getCommit(current.parent) : null;
+    }
+
+    return result.reverse();
+  }
+
+  /**
+   * Get all commits (for log)
+   */
+  getAllCommits(): CommitIndex[] {
+    return Array.from(this.hashIndex.values());
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): {
+    totalCommits: number;
+    uniqueAuthors: number;
+    branchCount: number;
+    oldestCommit?: CommitIndex;
+    newestCommit?: CommitIndex;
+  } {
+    const commits = Array.from(this.hashIndex.values());
+    const authors = new Set(commits.map(c => c.author));
+    const rootCommits = commits.filter(c => !c.parent);
+
+    let oldest = commits[0];
+    let newest = commits[0];
+
+    for (const commit of commits) {
+      if (commit.timestamp < oldest.timestamp) oldest = commit;
+      if (commit.timestamp > newest.timestamp) newest = commit;
+    }
+
+    return {
+      totalCommits: commits.length,
+      uniqueAuthors: authors.size,
+      branchCount: rootCommits.length,
+      oldestCommit: oldest,
+      newestCommit: newest,
+    };
+  }
+
+  /**
+   * Validate entire history
+   */
+  validateHistory(): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    for (const [hash, commit] of this.commits) {
+      // Verify parent exists
+      if (commit.parent) {
+        if (!this.commits.has(commit.parent)) {
+          errors.push(`Commit ${hash} has missing parent ${commit.parent}`);
+        }
+      }
+
+      // Verify hash consistency
+      const recomputed = CommitHashSystem.createHash(
+        commit.author,
+        commit.message,
+        commit.files,
+        commit.parent
+      );
+      if (recomputed.full !== hash) {
+        errors.push(`Commit ${hash} has inconsistent hash`);
+      }
+    }
+
+    // Verify parent-child index
+    for (const [parent, children] of this.parentChild) {
+      if (!this.commits.has(parent)) {
+        errors.push(`Parent index references non-existent commit ${parent}`);
+      }
+      for (const child of children) {
+        if (!this.commits.has(child)) {
+          errors.push(`Child index references non-existent commit ${child}`);
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+}
+
+export default CommitHashSystem;

package/src/compression.ts

@@ -0,0 +1,176 @@
+/**
+ * Compression Engine for Trace
+ * Delta-based storage for fast commits and minimal file size
+ */
+
+export interface Delta {
+  type: 'add' | 'modify' | 'delete';
+  path: string;
+  hash: string;
+  baseHash?: string;
+  size: number;
+  compressed: boolean;
+}
+
+export interface CompressionStats {
+  originalSize: number;
+  compressedSize: number;
+  ratio: number;
+  deltas: number;
+}
+
+export class CompressionEngine {
+  /**
+   * Calculate delta between two file versions
+   */
+  static calculateDelta(oldContent: string, newContent: string): string {
+    if (oldContent === newContent) return '';
+
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const delta: string[] = [];
+
+    // Simple line-based diff (production would use Levenshtein or similar)
+    for (let i = 0; i < Math.max(oldLines.length, newLines.length); i++) {
+      const oldLine = oldLines[i];
+      const newLine = newLines[i];
+
+      if (oldLine !== newLine) {
+        if (oldLine !== undefined) delta.push(`-${i}:${oldLine}`);
+        if (newLine !== undefined) delta.push(`+${i}:${newLine}`);
+      }
+    }
+
+    return delta.join('\n');
+  }
+
+  /**
+   * Compress content using deflate-like algorithm (mock)
+   */
+  static compress(content: string): { compressed: string; ratio: number } {
+    // In production, use zlib or similar
+    const compressed = Buffer.from(content).toString('base64');
+    const ratio = compressed.length > 0 ? content.length / compressed.length : 1;
+
+    return { compressed, ratio };
+  }
+
+  /**
+   * Decompress content
+   */
+  static decompress(compressed: string): string {
+    try {
+      return Buffer.from(compressed, 'base64').toString('utf-8');
+    } catch {
+      return compressed;
+    }
+  }
+
+  /**
+   * Calculate hash (simple checksum)
+   */
+  static hash(content: string): string {
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash).toString(36);
+  }
+
+  /**
+   * Create delta from two files
+   */
+  static createDelta(path: string, oldContent: string, newContent: string): Delta {
+    const delta = this.calculateDelta(oldContent, newContent);
+    const { compressed, ratio } = this.compress(delta);
+
+    return {
+      type: 'modify',
+      path,
+      hash: this.hash(newContent),
+      baseHash: this.hash(oldContent),
+      size: newContent.length,
+      compressed: ratio > 1,
+    };
+  }
+
+  /**
+   * Apply delta to reconstruct file
+   */
+  static applyDelta(baseContent: string, delta: string): string {
+    const lines = baseContent.split('\n');
+    const changes = delta.split('\n');
+
+    for (const change of changes) {
+      if (change.startsWith('-')) {
+        const [, lineNumStr, ...rest] = change.split(':');
+        const lineNum = parseInt(lineNumStr, 10);
+        if (lineNum >= 0 && lineNum < lines.length) {
+          lines[lineNum] = '';
+        }
+      } else if (change.startsWith('+')) {
+        const [, lineNumStr, ...rest] = change.split(':');
+        const lineNum = parseInt(lineNumStr, 10);
+        const newLine = rest.join(':');
+        if (lineNum >= 0) {
+          lines[lineNum] = newLine;
+        }
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Compress file set
+   */
+  static compressFileSet(files: Map<string, string>): { deltas: Delta[]; stats: CompressionStats } {
+    const deltas: Delta[] = [];
+    let originalSize = 0;
+    let compressedSize = 0;
+
+    for (const [path, content] of files) {
+      originalSize += content.length;
+
+      const { compressed } = this.compress(content);
+      compressedSize += compressed.length;
+
+      const hash = this.hash(content);
+
+      deltas.push({
+        type: 'add',
+        path,
+        hash,
+        size: content.length,
+        compressed: compressed.length < content.length,
+      });
+    }
+
+    return {
+      deltas,
+      stats: {
+        originalSize,
+        compressedSize,
+        ratio: originalSize > 0 ? originalSize / compressedSize : 1,
+        deltas: deltas.length,
+      },
+    };
+  }
+
+  /**
+   * Estimate compression benefit
+   */
+  static estimateBenefit(fileCount: number, avgFileSize: number): { savings: string; ratio: string } {
+    const originalSize = fileCount * avgFileSize;
+    // Typical compression ratio ~1.5-2x
+    const estimatedCompressed = originalSize / 1.7;
+    const savings = `${((originalSize - estimatedCompressed) / originalSize * 100).toFixed(1)}%`;
+    const ratio = `${(originalSize / estimatedCompressed).toFixed(2)}x`;
+
+    return { savings, ratio };
+  }
+}
+
+export default CompressionEngine;