@zoebuildsai/trace 1.5.0

package/src/rollback.ts

@@ -0,0 +1,215 @@
+/**
+ * Rollback Engine for Trace
+ * Reset to previous commit state (equivalent to git reset)
+ */
+
+export interface RollbackPoint {
+  commitId: string;
+  agentId: string;
+  timestamp: number;
+  message: string;
+  fileStates: Map<string, string>; // file -> content hash
+}
+
+export interface RollbackResult {
+  success: boolean;
+  fromCommit: string;
+  toCommit: string;
+  filesRestored: string[];
+  filesDiscarded: string[];
+  timestamp: number;
+}
+
+export class RollbackEngine {
+  private history: RollbackPoint[] = [];
+  private fileSnapshots: Map<string, Map<string, string>> = new Map(); // commitId -> fileStates
+
+  /**
+   * Create rollback point (snapshot)
+   */
+  createSnapshot(
+    commitId: string,
+    agentId: string,
+    message: string,
+    files: Map<string, string>
+  ): void {
+    const snapshot: RollbackPoint = {
+      commitId,
+      agentId,
+      timestamp: Date.now(),
+      message,
+      fileStates: new Map(files),
+    };
+
+    this.history.push(snapshot);
+    this.fileSnapshots.set(commitId, new Map(files));
+  }
+
+  /**
+   * Rollback to specific commit
+   */
+  rollbackToCommit(targetCommitId: string): RollbackResult {
+    const targetIndex = this.history.findIndex(h => h.commitId === targetCommitId);
+
+    if (targetIndex === -1) {
+      throw new Error(`Commit ${targetCommitId} not found`);
+    }
+
+    const currentCommit = this.history[this.history.length - 1];
+    const targetCommit = this.history[targetIndex];
+
+    const currentFiles = this.fileSnapshots.get(currentCommit.commitId) || new Map();
+    const targetFiles = this.fileSnapshots.get(targetCommitId) || new Map();
+
+    // Find what needs to be restored/discarded
+    const filesRestored: string[] = [];
+    const filesDiscarded: string[] = [];
+
+    // Files that exist in target but not in current (restore)
+    for (const file of targetFiles.keys()) {
+      if (!currentFiles.has(file)) {
+        filesRestored.push(file);
+      }
+    }
+
+    // Files that exist in current but not in target (discard)
+    for (const file of currentFiles.keys()) {
+      if (!targetFiles.has(file)) {
+        filesDiscarded.push(file);
+      }
+    }
+
+    // Truncate history to target
+    this.history = this.history.slice(0, targetIndex + 1);
+
+    return {
+      success: true,
+      fromCommit: currentCommit.commitId,
+      toCommit: targetCommitId,
+      filesRestored,
+      filesDiscarded,
+      timestamp: Date.now(),
+    };
+  }
+
+  /**
+   * Rollback N commits back
+   */
+  rollbackN(n: number): RollbackResult {
+    if (n < 1) throw new Error('N must be >= 1');
+    if (n > this.history.length) throw new Error('Cannot rollback more commits than exist');
+
+    const targetIndex = this.history.length - n - 1;
+    const targetCommit = this.history[targetIndex];
+
+    return this.rollbackToCommit(targetCommit.commitId);
+  }
+
+  /**
+   * Rollback to commit before agent's changes
+   */
+  rollbackBeforeAgent(agentId: string): RollbackResult {
+    const targetIndex = this.history.findLastIndex(h => h.agentId !== agentId);
+
+    if (targetIndex === -1) {
+      throw new Error(`No commits found before agent ${agentId}`);
+    }
+
+    const targetCommit = this.history[targetIndex];
+    return this.rollbackToCommit(targetCommit.commitId);
+  }
+
+  /**
+   * Get available rollback points
+   */
+  getRollbackPoints(limit: number = 10): RollbackPoint[] {
+    return this.history.slice(-limit).reverse();
+  }
+
+  /**
+   * Check if rollback is safe (no conflicts)
+   */
+  isRollbackSafe(targetCommitId: string): boolean {
+    const targetIndex = this.history.findIndex(h => h.commitId === targetCommitId);
+
+    if (targetIndex === -1) return false;
+
+    // Safe if no uncommitted changes would be lost
+    // (in real implementation, would check working directory)
+    return true;
+  }
+
+  /**
+   * Get diff between two commits
+   */
+  getDiffBetween(fromCommitId: string, toCommitId: string): Map<string, string> {
+    const fromFiles = this.fileSnapshots.get(fromCommitId) || new Map();
+    const toFiles = this.fileSnapshots.get(toCommitId) || new Map();
+
+    const diff = new Map<string, string>();
+
+    for (const [file, toHash] of toFiles) {
+      const fromHash = fromFiles.get(file);
+      if (fromHash !== toHash) {
+        diff.set(file, `${fromHash || 'NEW'} -> ${toHash}`);
+      }
+    }
+
+    for (const [file] of fromFiles) {
+      if (!toFiles.has(file)) {
+        diff.set(file, `DELETED`);
+      }
+    }
+
+    return diff;
+  }
+
+  /**
+   * Get history
+   */
+  getHistory(): RollbackPoint[] {
+    return [...this.history];
+  }
+
+  /**
+   * Get commit details
+   */
+  getCommit(commitId: string): RollbackPoint | undefined {
+    return this.history.find(h => h.commitId === commitId);
+  }
+
+  /**
+   * List all commits by agent
+   */
+  getCommitsByAgent(agentId: string): RollbackPoint[] {
+    return this.history.filter(h => h.agentId === agentId);
+  }
+
+  /**
+   * Verify rollback integrity
+   */
+  verifyIntegrity(): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    // Check history is chronological
+    for (let i = 0; i < this.history.length - 1; i++) {
+      if (this.history[i].timestamp > this.history[i + 1].timestamp) {
+        errors.push(`Timeline violation at commit ${i}`);
+      }
+    }
+
+    // Check snapshots match history
+    for (const commit of this.history) {
+      if (!this.fileSnapshots.has(commit.commitId)) {
+        errors.push(`Missing snapshot for commit ${commit.commitId}`);
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+}
+
+export default RollbackEngine;

package/src/semantic-grouping.ts

@@ -0,0 +1,245 @@
+/**
+ * Semantic Grouping for Trace
+ * Auto-categorizes changes by type (feature, fix, docs, test, refactor, perf, security)
+ */
+
+export type ChangeType = 'feature' | 'fix' | 'docs' | 'test' | 'refactor' | 'perf' | 'security' | 'chore' | 'unknown';
+
+export interface GroupedChange {
+  type: ChangeType;
+  files: string[];
+  count: number;
+  summary: string;
+}
+
+export interface SemanticGroup {
+  feature: GroupedChange | null;
+  fix: GroupedChange | null;
+  docs: GroupedChange | null;
+  test: GroupedChange | null;
+  refactor: GroupedChange | null;
+  perf: GroupedChange | null;
+  security: GroupedChange | null;
+  chore: GroupedChange | null;
+  unknown: GroupedChange | null;
+}
+
+export class SemanticGrouping {
+  /**
+   * Detect change type from file path and content
+   */
+  static detectType(filePath: string, commitMessage?: string): ChangeType {
+    // Pattern matching for file paths
+    if (this.matchesPattern(filePath, /\.(test|spec)\.ts$|__tests__|\.test\./)) {
+      return 'test';
+    }
+
+    if (this.matchesPattern(filePath, /README|\.md$|docs\//)) {
+      return 'docs';
+    }
+
+    if (this.matchesPattern(filePath, /security|auth|crypt|encrypt|hash|sign/)) {
+      return 'security';
+    }
+
+    if (this.matchesPattern(filePath, /perf|bench|cache|optim|compress/)) {
+      return 'perf';
+    }
+
+    if (this.matchesPattern(filePath, /refactor|cleanup|reorganize|rename/)) {
+      return 'refactor';
+    }
+
+    // Commit message patterns
+    if (commitMessage) {
+      const msg = commitMessage.toLowerCase();
+
+      if (msg.startsWith('fix:') || msg.startsWith('bugfix')) {
+        return 'fix';
+      }
+
+      if (msg.startsWith('feat:') || msg.startsWith('feature')) {
+        return 'feature';
+      }
+
+      if (msg.startsWith('docs:')) {
+        return 'docs';
+      }
+
+      if (msg.startsWith('test:')) {
+        return 'test';
+      }
+
+      if (msg.startsWith('perf:')) {
+        return 'perf';
+      }
+
+      if (msg.startsWith('security:') || msg.includes('security')) {
+        return 'security';
+      }
+
+      if (msg.startsWith('refactor:')) {
+        return 'refactor';
+      }
+
+      if (msg.startsWith('chore:')) {
+        return 'chore';
+      }
+    }
+
+    // Default heuristics
+    if (this.matchesPattern(filePath, /src\/.*\.ts$/)) {
+      return 'feature'; // src/ files are usually features
+    }
+
+    return 'unknown';
+  }
+
+  /**
+   * Group files by change type
+   */
+  static group(files: string[], commitMessage?: string): SemanticGroup {
+    const groups: Record<ChangeType, string[]> = {
+      feature: [],
+      fix: [],
+      docs: [],
+      test: [],
+      refactor: [],
+      perf: [],
+      security: [],
+      chore: [],
+      unknown: [],
+    };
+
+    for (const file of files) {
+      const type = this.detectType(file, commitMessage);
+      groups[type].push(file);
+    }
+
+    // Build result
+    const result: SemanticGroup = {
+      feature: groups.feature.length > 0 ? {
+        type: 'feature',
+        files: groups.feature,
+        count: groups.feature.length,
+        summary: `Added ${groups.feature.length} new feature(s)`,
+      } : null,
+      fix: groups.fix.length > 0 ? {
+        type: 'fix',
+        files: groups.fix,
+        count: groups.fix.length,
+        summary: `Fixed ${groups.fix.length} issue(s)`,
+      } : null,
+      docs: groups.docs.length > 0 ? {
+        type: 'docs',
+        files: groups.docs,
+        count: groups.docs.length,
+        summary: `Updated ${groups.docs.length} doc(s)`,
+      } : null,
+      test: groups.test.length > 0 ? {
+        type: 'test',
+        files: groups.test,
+        count: groups.test.length,
+        summary: `Added ${groups.test.length} test(s)`,
+      } : null,
+      refactor: groups.refactor.length > 0 ? {
+        type: 'refactor',
+        files: groups.refactor,
+        count: groups.refactor.length,
+        summary: `Refactored ${groups.refactor.length} file(s)`,
+      } : null,
+      perf: groups.perf.length > 0 ? {
+        type: 'perf',
+        files: groups.perf,
+        count: groups.perf.length,
+        summary: `Optimized ${groups.perf.length} file(s)`,
+      } : null,
+      security: groups.security.length > 0 ? {
+        type: 'security',
+        files: groups.security,
+        count: groups.security.length,
+        summary: `Enhanced security in ${groups.security.length} file(s)`,
+      } : null,
+      chore: groups.chore.length > 0 ? {
+        type: 'chore',
+        files: groups.chore,
+        count: groups.chore.length,
+        summary: `Maintenance: ${groups.chore.length} file(s)`,
+      } : null,
+      unknown: groups.unknown.length > 0 ? {
+        type: 'unknown',
+        files: groups.unknown,
+        count: groups.unknown.length,
+        summary: `Uncategorized: ${groups.unknown.length} file(s)`,
+      } : null,
+    };
+
+    return result;
+  }
+
+  /**
+   * Generate semantic commit message from grouped changes
+   */
+  static generateMessage(group: SemanticGroup): string {
+    const parts: string[] = [];
+
+    if (group.feature) {
+      parts.push(`✨ ${group.feature.summary}`);
+    }
+    if (group.fix) {
+      parts.push(`🐛 ${group.fix.summary}`);
+    }
+    if (group.security) {
+      parts.push(`🔒 ${group.security.summary}`);
+    }
+    if (group.perf) {
+      parts.push(`⚡ ${group.perf.summary}`);
+    }
+    if (group.test) {
+      parts.push(`✅ ${group.test.summary}`);
+    }
+    if (group.docs) {
+      parts.push(`📖 ${group.docs.summary}`);
+    }
+    if (group.refactor) {
+      parts.push(`♻️ ${group.refactor.summary}`);
+    }
+    if (group.chore) {
+      parts.push(`🧹 ${group.chore.summary}`);
+    }
+
+    return parts.join('\n');
+  }
+
+  /**
+   * Helper: match pattern against path
+   */
+  private static matchesPattern(path: string, pattern: RegExp): boolean {
+    return pattern.test(path);
+  }
+
+  /**
+   * Check if files represent a "micro" commit (minimal changes)
+   */
+  static isMicroCommit(files: string[], lineChanges?: number): boolean {
+    // Micro = few files, few lines
+    const fileCount = files.length;
+    const lines = lineChanges || 50;
+
+    return fileCount <= 5 && lines <= 100;
+  }
+
+  /**
+   * Get dominant change type (most files)
+   */
+  static getDominantType(group: SemanticGroup): ChangeType {
+    const types: (ChangeType | null)[] = Object.values(group);
+    const withCounts = types
+      .filter((t): t is ChangeType => t !== null)
+      .sort((a, b) => (group[b]?.count || 0) - (group[a]?.count || 0));
+
+    return withCounts[0] || 'unknown';
+  }
+}
+
+export default SemanticGrouping;