@zoebuildsai/trace 1.5.0

package/tests/v1.1/rollback.test.ts

@@ -0,0 +1,370 @@
+/**
+ * Rollback Engine Tests (TDD)
+ * Complete test coverage for reset/rollback functionality
+ */
+
+import { RollbackEngine, RollbackResult } from '../../src/rollback';
+
+describe('RollbackEngine - Comprehensive Tests', () => {
+  let rollback: RollbackEngine;
+
+  beforeEach(() => {
+    rollback = new RollbackEngine();
+  });
+
+  // ============ SNAPSHOT CREATION (20 tests) ============
+
+  describe('Snapshot Creation', () => {
+    test('creates snapshot with commit ID', () => {
+      rollback.createSnapshot('commit-1', 'agent-a', 'msg', new Map([['f.ts', 'hash']]));
+      expect(rollback.getCommit('commit-1')).toBeDefined();
+    });
+
+    test('snapshot includes agent ID', () => {
+      rollback.createSnapshot('c1', 'agent-xyz', 'msg', new Map());
+      const commit = rollback.getCommit('c1');
+      expect(commit?.agentId).toBe('agent-xyz');
+    });
+
+    test('snapshot includes message', () => {
+      rollback.createSnapshot('c1', 'a1', 'Important change', new Map());
+      expect(rollback.getCommit('c1')?.message).toBe('Important change');
+    });
+
+    test('snapshot includes timestamp', () => {
+      rollback.createSnapshot('c1', 'a1', 'msg', new Map());
+      const commit = rollback.getCommit('c1');
+      expect(commit?.timestamp).toBeGreaterThan(0);
+    });
+
+    test('snapshot preserves file states', () => {
+      const files = new Map([['a.ts', 'h1'], ['b.ts', 'h2']]);
+      rollback.createSnapshot('c1', 'a1', 'msg', files);
+      const commit = rollback.getCommit('c1');
+      expect(commit?.fileStates.size).toBe(2);
+    });
+
+    test('multiple snapshots maintain order', () => {
+      rollback.createSnapshot('c1', 'a1', 'm1', new Map());
+      rollback.createSnapshot('c2', 'a1', 'm2', new Map());
+      rollback.createSnapshot('c3', 'a1', 'm3', new Map());
+      const history = rollback.getHistory();
+      expect(history[0].commitId).toBe('c1');
+      expect(history[2].commitId).toBe('c3');
+    });
+
+    test('supports 100 snapshots', () => {
+      for (let i = 0; i < 100; i++) {
+        rollback.createSnapshot(`c${i}`, `a1`, `msg${i}`, new Map([[`f${i}.ts`, `h${i}`]]));
+      }
+      const history = rollback.getHistory();
+      expect(history).toHaveLength(100);
+    });
+  });
+
+  // ============ ROLLBACK TO COMMIT (20 tests) ============
+
+  describe('Rollback to Specific Commit', () => {
+    beforeEach(() => {
+      rollback.createSnapshot('c1', 'a1', 'm1', new Map([['f1.ts', 'h1']]));
+      rollback.createSnapshot('c2', 'a1', 'm2', new Map([['f1.ts', 'h2'], ['f2.ts', 'h2']]));
+      rollback.createSnapshot('c3', 'a1', 'm3', new Map([['f2.ts', 'h3']]));
+    });
+
+    test('rollback to middle commit', () => {
+      const result = rollback.rollbackToCommit('c2');
+      expect(result.success).toBe(true);
+      expect(result.toCommit).toBe('c2');
+    });
+
+    test('rollback to first commit', () => {
+      const result = rollback.rollbackToCommit('c1');
+      expect(result.success).toBe(true);
+      expect(result.filesDiscarded).toContain('f2.ts');
+    });
+
+    test('detects files to restore', () => {
+      const result = rollback.rollbackToCommit('c2');
+      expect(Array.isArray(result.filesRestored)).toBe(true);
+    });
+
+    test('detects files to discard', () => {
+      const result = rollback.rollbackToCommit('c1');
+      expect(Array.isArray(result.filesDiscarded)).toBe(true);
+    });
+
+    test('rejects unknown commit', () => {
+      expect(() => {
+        rollback.rollbackToCommit('unknown');
+      }).toThrow();
+    });
+
+    test('records rollback result', () => {
+      const result = rollback.rollbackToCommit('c2');
+      expect(result.fromCommit).toBe('c3');
+      expect(result.toCommit).toBe('c2');
+      expect(result.timestamp).toBeGreaterThan(0);
+    });
+
+    test('updates history after rollback', () => {
+      rollback.rollbackToCommit('c2');
+      const history = rollback.getHistory();
+      expect(history.length).toBeLessThanOrEqual(2);
+    });
+
+    test('rollback is atomic', () => {
+      const before = rollback.getHistory().length;
+      rollback.rollbackToCommit('c1');
+      const after = rollback.getHistory().length;
+      expect(after).toBeLessThan(before);
+    });
+  });
+
+  // ============ ROLLBACK N COMMITS (15 tests) ============
+
+  describe('Rollback N Commits Back', () => {
+    beforeEach(() => {
+      for (let i = 0; i < 10; i++) {
+        rollback.createSnapshot(`c${i}`, 'a1', `m${i}`, new Map([[`f${i}.ts`, `h${i}`]]));
+      }
+    });
+
+    test('rollback 1 commit', () => {
+      const result = rollback.rollbackN(1);
+      expect(result.success).toBe(true);
+    });
+
+    test('rollback 3 commits', () => {
+      const result = rollback.rollbackN(3);
+      expect(result.success).toBe(true);
+    });
+
+    test('rollback all but first', () => {
+      const result = rollback.rollbackN(9);
+      expect(result.success).toBe(true);
+    });
+
+    test('rejects N = 0', () => {
+      expect(() => {
+        rollback.rollbackN(0);
+      }).toThrow();
+    });
+
+    test('rejects N > history length', () => {
+      expect(() => {
+        rollback.rollbackN(100);
+      }).toThrow();
+    });
+
+    test('maintains chronological order after rollback', () => {
+      rollback.rollbackN(2);
+      const history = rollback.getHistory();
+      for (let i = 0; i < history.length - 1; i++) {
+        expect(history[i].timestamp).toBeLessThanOrEqual(history[i + 1].timestamp);
+      }
+    });
+  });
+
+  // ============ ROLLBACK BEFORE AGENT (10 tests) ============
+
+  describe('Rollback Before Agent', () => {
+    beforeEach(() => {
+      rollback.createSnapshot('c1', 'a1', 'm', new Map());
+      rollback.createSnapshot('c2', 'a1', 'm', new Map());
+      rollback.createSnapshot('c3', 'a2', 'm', new Map());
+      rollback.createSnapshot('c4', 'a2', 'm', new Map());
+    });
+
+    test('rollback before agent-2', () => {
+      const result = rollback.rollbackBeforeAgent('a2');
+      expect(result.success).toBe(true);
+    });
+
+    test('rejects rollback if agent never committed', () => {
+      expect(() => {
+        rollback.rollbackBeforeAgent('agent-never-existed');
+      }).toThrow();
+    });
+
+    test('finds last commit before agent', () => {
+      const result = rollback.rollbackBeforeAgent('a2');
+      expect(result.toCommit).toBe('c2');
+    });
+  });
+
+  // ============ DIFF BETWEEN COMMITS (10 tests) ============
+
+  describe('Diff Between Commits', () => {
+    beforeEach(() => {
+      rollback.createSnapshot('c1', 'a1', 'm', new Map([['f1.ts', 'h1'], ['f2.ts', 'h2']]));
+      rollback.createSnapshot('c2', 'a1', 'm', new Map([['f1.ts', 'h1x'], ['f3.ts', 'h3']]));
+    });
+
+    test('identifies modified files', () => {
+      const diff = rollback.getDiffBetween('c1', 'c2');
+      expect(diff.has('f1.ts')).toBe(true);
+    });
+
+    test('identifies new files', () => {
+      const diff = rollback.getDiffBetween('c1', 'c2');
+      expect(diff.has('f3.ts')).toBe(true);
+    });
+
+    test('identifies deleted files', () => {
+      const diff = rollback.getDiffBetween('c1', 'c2');
+      expect(diff.has('f2.ts')).toBe(true);
+    });
+
+    test('diff is empty for identical commits', () => {
+      const diff = rollback.getDiffBetween('c1', 'c1');
+      expect(diff.size).toBe(0);
+    });
+  });
+
+  // ============ QUERY OPERATIONS (10 tests) ============
+
+  describe('Query Operations', () => {
+    beforeEach(() => {
+      rollback.createSnapshot('c1', 'a1', 'm', new Map());
+      rollback.createSnapshot('c2', 'a1', 'm', new Map());
+      rollback.createSnapshot('c3', 'a2', 'm', new Map());
+    });
+
+    test('getRollbackPoints returns recent snapshots', () => {
+      const points = rollback.getRollbackPoints(2);
+      expect(points.length).toBeLessThanOrEqual(2);
+    });
+
+    test('getCommitsByAgent returns agent commits', () => {
+      const commits = rollback.getCommitsByAgent('a1');
+      expect(commits).toHaveLength(2);
+    });
+
+    test('getCommitsByAgent excludes other agents', () => {
+      const commits = rollback.getCommitsByAgent('a1');
+      expect(commits.every(c => c.agentId === 'a1')).toBe(true);
+    });
+
+    test('getHistory preserves order', () => {
+      const history = rollback.getHistory();
+      expect(history[0].commitId).toBe('c1');
+      expect(history[2].commitId).toBe('c3');
+    });
+
+    test('getCommit returns undefined for unknown', () => {
+      const commit = rollback.getCommit('unknown');
+      expect(commit).toBeUndefined();
+    });
+  });
+
+  // ============ SAFETY & INTEGRITY (15 tests) ============
+
+  describe('Safety & Integrity', () => {
+    beforeEach(() => {
+      rollback.createSnapshot('c1', 'a1', 'm1', new Map([['f.ts', 'h1']]));
+      rollback.createSnapshot('c2', 'a1', 'm2', new Map([['f.ts', 'h2']]));
+    });
+
+    test('isRollbackSafe returns boolean', () => {
+      const safe = rollback.isRollbackSafe('c1');
+      expect(typeof safe).toBe('boolean');
+    });
+
+    test('isRollbackSafe false for unknown commit', () => {
+      const safe = rollback.isRollbackSafe('unknown');
+      expect(safe).toBe(false);
+    });
+
+    test('verifyIntegrity returns valid state', () => {
+      const result = rollback.verifyIntegrity();
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('verifyIntegrity checks chronological order', () => {
+      const result = rollback.verifyIntegrity();
+      expect(Array.isArray(result.errors)).toBe(true);
+    });
+
+    test('handles 1000 commits without integrity issues', () => {
+      const rb = new RollbackEngine();
+      for (let i = 0; i < 1000; i++) {
+        rb.createSnapshot(`c${i}`, 'a1', `m${i}`, new Map([[`f${i}.ts`, `h${i}`]]));
+      }
+      const result = rb.verifyIntegrity();
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  // ============ STRESS TESTS (10+ tests) ============
+
+  describe('Performance & Stress', () => {
+    test('creates 1000 snapshots quickly', () => {
+      const start = Date.now();
+      for (let i = 0; i < 1000; i++) {
+        rollback.createSnapshot(`c${i}`, `a${i % 10}`, `msg${i}`, new Map([[`f${i}.ts`, `h${i}`]]));
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(500);
+    });
+
+    test('rollback from deep history quickly', () => {
+      for (let i = 0; i < 100; i++) {
+        rollback.createSnapshot(`c${i}`, 'a1', `msg${i}`, new Map());
+      }
+      const start = Date.now();
+      rollback.rollbackToCommit('c50');
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(50);
+    });
+
+    test('getDiffBetween with large histories', () => {
+      for (let i = 0; i < 100; i++) {
+        rollback.createSnapshot(`c${i}`, 'a1', `m${i}`, new Map([[`f${i}.ts`, `h${i}`]]));
+      }
+      const start = Date.now();
+      rollback.getDiffBetween('c10', 'c90');
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(50);
+    });
+  });
+
+  // ============ EDGE CASES (10 tests) ============
+
+  describe('Edge Cases', () => {
+    test('empty snapshot', () => {
+      rollback.createSnapshot('c1', 'a1', 'm', new Map());
+      expect(rollback.getCommit('c1')?.fileStates.size).toBe(0);
+    });
+
+    test('snapshot with many files', () => {
+      const files = new Map();
+      for (let i = 0; i < 1000; i++) {
+        files.set(`f${i}.ts`, `h${i}`);
+      }
+      rollback.createSnapshot('c1', 'a1', 'm', files);
+      expect(rollback.getCommit('c1')?.fileStates.size).toBe(1000);
+    });
+
+    test('special characters in message', () => {
+      rollback.createSnapshot('c1', 'a1', 'msg with 🚀 emoji', new Map());
+      expect(rollback.getCommit('c1')?.message).toContain('🚀');
+    });
+
+    test('rollback chain (multiple rollbacks)', () => {
+      for (let i = 0; i < 5; i++) {
+        rollback.createSnapshot(`c${i}`, 'a1', `m${i}`, new Map());
+      }
+      rollback.rollbackToCommit('c3');
+      rollback.rollbackToCommit('c2');
+      const history = rollback.getHistory();
+      expect(history.length).toBeLessThanOrEqual(2);
+    });
+
+    test('agent with single commit', () => {
+      rollback.createSnapshot('c1', 'a1', 'm', new Map());
+      const commits = rollback.getCommitsByAgent('a1');
+      expect(commits).toHaveLength(1);
+    });
+  });
+});

package/tests/v1.1/semantic-grouping.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Semantic Grouping Tests (TDD)
+ * Tests for change type detection and grouping
+ */
+
+import { SemanticGrouping, ChangeType } from '../../src/semantic-grouping';
+
+describe('SemanticGrouping', () => {
+  describe('Type Detection', () => {
+    test('should detect test files', () => {
+      expect(SemanticGrouping.detectType('file.test.ts')).toBe('test');
+      expect(SemanticGrouping.detectType('file.spec.ts')).toBe('test');
+      expect(SemanticGrouping.detectType('__tests__/file.ts')).toBe('test');
+    });
+
+    test('should detect documentation files', () => {
+      expect(SemanticGrouping.detectType('README.md')).toBe('docs');
+      expect(SemanticGrouping.detectType('docs/guide.md')).toBe('docs');
+      expect(SemanticGrouping.detectType('CHANGELOG.md')).toBe('docs');
+    });
+
+    test('should detect security-related files', () => {
+      expect(SemanticGrouping.detectType('src/security.ts')).toBe('security');
+      expect(SemanticGrouping.detectType('src/auth.ts')).toBe('security');
+      expect(SemanticGrouping.detectType('src/encrypt.ts')).toBe('security');
+    });
+
+    test('should detect performance-related files', () => {
+      expect(SemanticGrouping.detectType('src/cache.ts')).toBe('perf');
+      expect(SemanticGrouping.detectType('src/optimize.ts')).toBe('perf');
+      expect(SemanticGrouping.detectType('benchmarks/perf.ts')).toBe('perf');
+    });
+
+    test('should detect from commit message', () => {
+      expect(SemanticGrouping.detectType('any/file.ts', 'fix: critical bug')).toBe('fix');
+      expect(SemanticGrouping.detectType('any/file.ts', 'feat: new feature')).toBe('feature');
+      expect(SemanticGrouping.detectType('any/file.ts', 'docs: update readme')).toBe('docs');
+      expect(SemanticGrouping.detectType('any/file.ts', 'perf: optimize loop')).toBe('perf');
+    });
+
+    test('should default to feature for src/ files', () => {
+      expect(SemanticGrouping.detectType('src/new-feature.ts')).toBe('feature');
+    });
+
+    test('should default to unknown for unmatched files', () => {
+      expect(SemanticGrouping.detectType('some/random/file.txt')).toBe('unknown');
+    });
+  });
+
+  describe('Grouping', () => {
+    test('should group files by type', () => {
+      const files = [
+        'src/feature.ts',
+        'tests/feature.test.ts',
+        'README.md',
+        'src/auth.ts',
+      ];
+
+      const group = SemanticGrouping.group(files);
+
+      expect(group.feature?.count).toBe(1);
+      expect(group.test?.count).toBe(1);
+      expect(group.docs?.count).toBe(1);
+      expect(group.security?.count).toBe(1);
+    });
+
+    test('should handle single-type commits', () => {
+      const files = ['src/feature1.ts', 'src/feature2.ts', 'src/feature3.ts'];
+      const group = SemanticGrouping.group(files);
+
+      expect(group.feature?.count).toBe(3);
+      expect(group.test).toBeNull();
+      expect(group.docs).toBeNull();
+    });
+
+    test('should generate semantic commit message', () => {
+      const files = [
+        'src/feature.ts',
+        'tests/feature.test.ts',
+        'src/auth.ts',
+        'README.md',
+      ];
+
+      const group = SemanticGrouping.group(files);
+      const message = SemanticGrouping.generateMessage(group);
+
+      expect(message).toContain('✨'); // feature
+      expect(message).toContain('✅'); // test
+      expect(message).toContain('🔒'); // security
+      expect(message).toContain('📖'); // docs
+    });
+
+    test('should identify dominant change type', () => {
+      const files = [
+        'src/feature1.ts',
+        'src/feature2.ts',
+        'src/feature3.ts',
+        'tests/one.test.ts',
+      ];
+
+      const group = SemanticGrouping.group(files);
+      const dominant = SemanticGrouping.getDominantType(group);
+
+      expect(dominant).toBe('feature');
+    });
+  });
+
+  describe('Micro-commits', () => {
+    test('should identify micro-commit (few files, few lines)', () => {
+      const files = ['src/one.ts', 'src/two.ts'];
+      const isMicro = SemanticGrouping.isMicroCommit(files, 50);
+
+      expect(isMicro).toBe(true);
+    });
+
+    test('should reject large commits as non-micro', () => {
+      const files = Array.from({ length: 20 }, (_, i) => `file${i}.ts`);
+      const isMicro = SemanticGrouping.isMicroCommit(files, 500);
+
+      expect(isMicro).toBe(false);
+    });
+
+    test('should use default line count threshold', () => {
+      const files = ['file.ts'];
+      const isMicro = SemanticGrouping.isMicroCommit(files);
+
+      expect(isMicro).toBe(true);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle empty file list', () => {
+      const group = SemanticGrouping.group([]);
+
+      expect(group.feature).toBeNull();
+      expect(group.test).toBeNull();
+      expect(group.docs).toBeNull();
+    });
+
+    test('should handle mixed case commit messages', () => {
+      expect(SemanticGrouping.detectType('file.ts', 'FIX: uppercase')).toBe('fix');
+      expect(SemanticGrouping.detectType('file.ts', 'Fix: mixed')).toBe('fix');
+    });
+
+    test('should handle files with multiple extensions', () => {
+      expect(SemanticGrouping.detectType('file.test.ts')).toBe('test');
+      expect(SemanticGrouping.detectType('archive.test.tar.gz')).toBe('test');
+    });
+
+    test('should prioritize path patterns over defaults', () => {
+      expect(SemanticGrouping.detectType('src/test-utils.ts')).toBe('feature');
+      expect(SemanticGrouping.detectType('src/auth-test.ts')).toBe('security');
+    });
+  });
+
+  describe('Performance', () => {
+    test('should classify 1000 files quickly', () => {
+      const files = Array.from({ length: 1000 }, (_, i) => {
+        const types = ['src/', 'tests/', 'docs/', 'security/', 'perf/'];
+        const type = types[i % types.length];
+        return `${type}file${i}.ts`;
+      });
+
+      const start = Date.now();
+      const group = SemanticGrouping.group(files);
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(50); // Should be very fast
+      expect(Object.values(group).filter(g => g !== null).length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Semantic Messages', () => {
+    test('should include all relevant emoji', () => {
+      const files = [
+        'src/feature.ts',
+        'src/bug-fix.ts',
+        'src/auth.ts',
+        'src/cache.ts',
+        'tests/all.test.ts',
+        'README.md',
+      ];
+
+      // Override detection to ensure all types present
+      const group = {
+        feature: { type: 'feature' as const, files: ['src/feature.ts'], count: 1, summary: 'test' },
+        fix: { type: 'fix' as const, files: ['src/bug-fix.ts'], count: 1, summary: 'test' },
+        security: { type: 'security' as const, files: ['src/auth.ts'], count: 1, summary: 'test' },
+        perf: { type: 'perf' as const, files: ['src/cache.ts'], count: 1, summary: 'test' },
+        test: { type: 'test' as const, files: ['tests/all.test.ts'], count: 1, summary: 'test' },
+        docs: { type: 'docs' as const, files: ['README.md'], count: 1, summary: 'test' },
+        refactor: null,
+        chore: null,
+        unknown: null,
+      };
+
+      const message = SemanticGrouping.generateMessage(group);
+
+      expect(message).toContain('✨');
+      expect(message).toContain('🐛');
+      expect(message).toContain('🔒');
+      expect(message).toContain('⚡');
+      expect(message).toContain('✅');
+      expect(message).toContain('📖');
+    });
+  });
+
+  describe('Real-world Scenarios', () => {
+    test('should handle mixed commit from real v1.1 work', () => {
+      const files = [
+        'src/async-queue.ts',
+        'src/webhooks.ts',
+        'tests/v1.1/async-queue.test.ts',
+        'tests/v1.1/webhooks.test.ts',
+        'docs/ASYNC-API.md',
+      ];
+
+      const group = SemanticGrouping.group(files, 'feat(v1.1): async queue and webhooks');
+
+      expect(group.feature?.count).toBe(2);
+      expect(group.test?.count).toBe(2);
+      expect(group.docs?.count).toBe(1);
+
+      const message = SemanticGrouping.generateMessage(group);
+      expect(message).toContain('✨');
+      expect(message).toContain('✅');
+      expect(message).toContain('📖');
+    });
+  });
+});