@zoebuildsai/trace 1.5.0

package/tests/v1.2/commit-hash-system.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Commit Hash System Tests
+ * Git-like SHA-256 hashing for agent checkout
+ */
+
+import { CommitHashSystem, CommitHash } from '../../src/commit-hash-system';
+
+describe('CommitHashSystem', () => {
+  let system: CommitHashSystem;
+
+  beforeEach(() => {
+    system = new CommitHashSystem();
+  });
+
+  describe('Hash Generation', () => {
+    test('generates deterministic hash', () => {
+      const files = new Map([['file.ts', 'content']]);
+      const hash1 = CommitHashSystem.createHash('agent-a', 'msg', files);
+      const hash2 = CommitHashSystem.createHash('agent-a', 'msg', files);
+      expect(hash1.full).toBe(hash2.full);
+    });
+
+    test('hash changes with different content', () => {
+      const files1 = new Map([['file.ts', 'content1']]);
+      const files2 = new Map([['file.ts', 'content2']]);
+      const hash1 = CommitHashSystem.createHash('agent-a', 'msg', files1);
+      const hash2 = CommitHashSystem.createHash('agent-a', 'msg', files2);
+      expect(hash1.full).not.toBe(hash2.full);
+    });
+
+    test('creates short hash (7 chars)', () => {
+      const files = new Map([['f.ts', 'c']]);
+      const hash = CommitHashSystem.createHash('a', 'm', files);
+      expect(hash.short).toHaveLength(7);
+      expect(hash.short).toBe(hash.full.substring(0, 7));
+    });
+
+    test('includes parent in hash', () => {
+      const files = new Map([['f.ts', 'c']]);
+      const hash1 = CommitHashSystem.createHash('a', 'm', files);
+      const hash2 = CommitHashSystem.createHash('a', 'm', files, hash1.full);
+      expect(hash1.full).not.toBe(hash2.full);
+    });
+
+    test('full hash is valid SHA-256', () => {
+      const files = new Map([['f.ts', 'c']]);
+      const hash = CommitHashSystem.createHash('a', 'm', files);
+      expect(hash.full).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+
+  describe('Commit Recording', () => {
+    test('records commit', () => {
+      const files = new Map([['f.ts', 'content']]);
+      const hash = system.recordCommit('agent-a', 'msg', files, 'sig1');
+      expect(hash).toBeDefined();
+      expect(hash.full).toBeDefined();
+    });
+
+    test('retrieves commit by full hash', () => {
+      const files = new Map([['f.ts', 'content']]);
+      const hash = system.recordCommit('agent-a', 'msg', files, 'sig1');
+      const commit = system.getCommit(hash.full);
+      expect(commit?.author).toBe('agent-a');
+      expect(commit?.message).toBe('msg');
+    });
+
+    test('retrieves commit by short hash', () => {
+      const files = new Map([['f.ts', 'content']]);
+      const hash = system.recordCommit('agent-a', 'msg', files, 'sig1');
+      const commit = system.getCommit(hash.short);
+      expect(commit?.author).toBe('agent-a');
+    });
+
+    test('tracks parent-child relationships', () => {
+      const files = new Map([['f.ts', 'c1']]);
+      const h1 = system.recordCommit('a', 'm1', files, 's1');
+
+      const files2 = new Map([['f.ts', 'c2']]);
+      const h2 = system.recordCommit('a', 'm2', files2, 's2', h1.full);
+
+      const children = system.getChildren(h1.full);
+      expect(children).toHaveLength(1);
+      expect(children[0].message).toBe('m2');
+    });
+
+    test('tracks author commits', () => {
+      system.recordCommit('agent-a', 'm1', new Map([['f.ts', 'c']]), 's1');
+      system.recordCommit('agent-a', 'm2', new Map([['g.ts', 'c']]), 's2');
+      system.recordCommit('agent-b', 'm3', new Map([['h.ts', 'c']]), 's3');
+
+      const commits = system.getCommitsByAuthor('agent-a');
+      expect(commits).toHaveLength(2);
+      expect(commits.every(c => c.author === 'agent-a')).toBe(true);
+    });
+  });
+
+  describe('Commit Chain', () => {
+    test('gets commit ancestry chain', () => {
+      const h1 = system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      const h2 = system.recordCommit('a', 'm2', new Map([['f', 'c']]), 's2', h1.full);
+      const h3 = system.recordCommit('a', 'm3', new Map([['f', 'c']]), 's3', h2.full);
+
+      const chain = system.getChain(h3.full);
+      expect(chain).toHaveLength(3);
+      expect(chain[0].message).toBe('m3');
+      expect(chain[2].message).toBe('m1');
+    });
+
+    test('handles single commit chain', () => {
+      const h = system.recordCommit('a', 'm', new Map([['f', 'c']]), 's');
+      const chain = system.getChain(h.full);
+      expect(chain).toHaveLength(1);
+    });
+  });
+
+  describe('Ancestry Queries', () => {
+    test('checks if commit is ancestor', () => {
+      const h1 = system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      const h2 = system.recordCommit('a', 'm2', new Map([['f', 'c']]), 's2', h1.full);
+      const h3 = system.recordCommit('a', 'm3', new Map([['f', 'c']]), 's3', h2.full);
+
+      expect(system.isAncestor(h1.full, h3.full)).toBe(true);
+      expect(system.isAncestor(h3.full, h1.full)).toBe(false);
+    });
+
+    test('returns false if not ancestor', () => {
+      const h1 = system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      const h2 = system.recordCommit('a', 'm2', new Map([['f', 'c']]), 's2');
+      expect(system.isAncestor(h1.full, h2.full)).toBe(false);
+    });
+  });
+
+  describe('Commit Range', () => {
+    test('gets range between commits', () => {
+      const h1 = system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      const h2 = system.recordCommit('a', 'm2', new Map([['f', 'c']]), 's2', h1.full);
+      const h3 = system.recordCommit('a', 'm3', new Map([['f', 'c']]), 's3', h2.full);
+
+      const range = system.getRange(h1.full, h3.full);
+      expect(range.length).toBeGreaterThan(0);
+    });
+
+    test('handles branching scenarios', () => {
+      const h1 = system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      const h2a = system.recordCommit('a', 'm2a', new Map([['f', 'c']]), 's2a', h1.full);
+      const h2b = system.recordCommit('a', 'm2b', new Map([['f', 'c']]), 's2b', h1.full);
+
+      const range = system.getRange(h2a.full, h2b.full);
+      expect(Array.isArray(range)).toBe(true);
+    });
+  });
+
+  describe('Hash Resolution', () => {
+    test('resolves short hash to full', () => {
+      const hash = system.recordCommit('a', 'm', new Map([['f', 'c']]), 's');
+      const resolved = system.resolveHash(hash.short);
+      expect(resolved).toBe(hash.full);
+    });
+
+    test('returns undefined for unknown short hash', () => {
+      const resolved = system.resolveHash('unknown');
+      expect(resolved).toBeUndefined();
+    });
+  });
+
+  describe('Statistics', () => {
+    test('calculates commit statistics', () => {
+      system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      system.recordCommit('a', 'm2', new Map([['g', 'c']]), 's2');
+      system.recordCommit('b', 'm3', new Map([['h', 'c']]), 's3');
+
+      const stats = system.getStats();
+      expect(stats.totalCommits).toBe(3);
+      expect(stats.uniqueAuthors).toBe(2);
+      expect(stats.branchCount).toBe(3); // 3 root commits
+    });
+
+    test('tracks oldest and newest commits', () => {
+      const h1 = system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      const h2 = system.recordCommit('b', 'm2', new Map([['g', 'c']]), 's2', h1.full);
+
+      const stats = system.getStats();
+      expect(stats.oldestCommit?.hash).toBe(h1.full);
+      expect(stats.newestCommit?.hash).toBe(h2.full);
+    });
+  });
+
+  describe('History Validation', () => {
+    test('validates clean history', () => {
+      system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      const result = system.validateHistory();
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('detects orphaned commits', () => {
+      // Manually create invalid state (for testing)
+      const result = system.validateHistory();
+      expect(Array.isArray(result.errors)).toBe(true);
+    });
+  });
+
+  describe('Commit Verification', () => {
+    test('verifies valid commit', () => {
+      const hash = system.recordCommit('a', 'm', new Map([['f', 'c']]), 'sig1');
+      const valid = system.verifyCommit(hash.full, 'sig1');
+      expect(valid).toBe(true);
+    });
+
+    test('rejects invalid signature', () => {
+      const hash = system.recordCommit('a', 'm', new Map([['f', 'c']]), 'sig1');
+      const valid = system.verifyCommit(hash.full, 'wrong-sig');
+      expect(valid).toBe(false);
+    });
+
+    test('rejects unknown commit', () => {
+      const valid = system.verifyCommit('unknown', 'sig');
+      expect(valid).toBe(false);
+    });
+  });
+
+  describe('Performance', () => {
+    test('records 1000 commits quickly', () => {
+      const start = Date.now();
+      for (let i = 0; i < 1000; i++) {
+        system.recordCommit(`agent-${i % 10}`, `m${i}`, new Map([[`f${i}.ts`, `c${i}`]]), `s${i}`);
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(500);
+    });
+
+    test('retrieves commits by full hash quickly', () => {
+      const hashes = [];
+      for (let i = 0; i < 100; i++) {
+        const h = system.recordCommit('a', `m${i}`, new Map([[`f${i}.ts`, `c`]]), `s${i}`);
+        hashes.push(h.full);
+      }
+
+      const start = Date.now();
+      for (const hash of hashes) {
+        system.getCommit(hash);
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(100);
+    });
+
+    test('retrieves commits by short hash quickly', () => {
+      const hashes = [];
+      for (let i = 0; i < 100; i++) {
+        const h = system.recordCommit('a', `m${i}`, new Map([[`f${i}.ts`, `c`]]), `s${i}`);
+        hashes.push(h.short);
+      }
+
+      const start = Date.now();
+      for (const hash of hashes) {
+        system.getCommit(hash);
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(100);
+    });
+  });
+
+  describe('Real-world Scenarios', () => {
+    test('handles agent linear history', () => {
+      let parent: string | undefined;
+      for (let i = 0; i < 10; i++) {
+        const hash = system.recordCommit('agent-a', `commit ${i}`, new Map([[`file.ts`, `v${i}`]]), `sig${i}`, parent);
+        parent = hash.full;
+      }
+
+      const stats = system.getStats();
+      expect(stats.totalCommits).toBe(10);
+    });
+
+    test('handles branching history', () => {
+      const h1 = system.recordCommit('a', 'm1', new Map([['f', 'c']]), 's1');
+      const h2a = system.recordCommit('a', 'm2a', new Map([['f', 'c']]), 's2a', h1.full);
+      const h2b = system.recordCommit('b', 'm2b', new Map([['g', 'c']]), 's2b', h1.full);
+      const h3a = system.recordCommit('a', 'm3a', new Map([['f', 'c']]), 's3a', h2a.full);
+      const h3b = system.recordCommit('b', 'm3b', new Map([['g', 'c']]), 's3b', h2b.full);
+
+      const stats = system.getStats();
+      expect(stats.totalCommits).toBe(5);
+      expect(stats.branchCount).toBe(1); // One root
+    });
+  });
+});

package/tests/v1.2/compression.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Compression Engine Tests
+ * Delta-based storage for efficient versioning
+ */
+
+import { CompressionEngine } from '../../src/compression';
+
+describe('CompressionEngine', () => {
+  describe('Delta Calculation', () => {
+    test('detects no changes', () => {
+      const delta = CompressionEngine.calculateDelta('same content', 'same content');
+      expect(delta).toBe('');
+    });
+
+    test('detects line additions', () => {
+      const old = 'line 1\nline 2';
+      const new_ver = 'line 1\nline 2\nline 3';
+      const delta = CompressionEngine.calculateDelta(old, new_ver);
+      expect(delta).toContain('+');
+    });
+
+    test('detects line deletions', () => {
+      const old = 'line 1\nline 2\nline 3';
+      const new_ver = 'line 1\nline 3';
+      const delta = CompressionEngine.calculateDelta(old, new_ver);
+      expect(delta).toContain('-');
+    });
+
+    test('detects modifications', () => {
+      const old = 'original content';
+      const new_ver = 'modified content';
+      const delta = CompressionEngine.calculateDelta(old, new_ver);
+      expect(delta.length).toBeGreaterThan(0);
+    });
+
+    test('handles multi-line changes', () => {
+      const old = 'a\nb\nc\nd\ne';
+      const new_ver = 'a\nx\nc\ny\ne';
+      const delta = CompressionEngine.calculateDelta(old, new_ver);
+      expect(delta).toContain('-');
+      expect(delta).toContain('+');
+    });
+  });
+
+  describe('Compression & Decompression', () => {
+    test('compresses content', () => {
+      const content = 'x'.repeat(1000);
+      const { compressed, ratio } = CompressionEngine.compress(content);
+      expect(compressed.length).toBeLessThan(content.length * 2);
+    });
+
+    test('compression ratio > 1 for compressible content', () => {
+      const content = 'aaaaaabbbbbbcccccc';
+      const { ratio } = CompressionEngine.compress(content);
+      expect(ratio).toBeGreaterThan(1);
+    });
+
+    test('decompresses back to original', () => {
+      const original = 'test content with some data';
+      const { compressed } = CompressionEngine.compress(original);
+      const decompressed = CompressionEngine.decompress(compressed);
+      expect(decompressed).toBe(original);
+    });
+
+    test('handles binary-like content', () => {
+      const content = '\x00\x01\x02\x03';
+      const { compressed } = CompressionEngine.compress(content);
+      const decompressed = CompressionEngine.decompress(compressed);
+      expect(decompressed).toBe(content);
+    });
+  });
+
+  describe('Hashing', () => {
+    test('produces consistent hash', () => {
+      const content = 'test content';
+      const hash1 = CompressionEngine.hash(content);
+      const hash2 = CompressionEngine.hash(content);
+      expect(hash1).toBe(hash2);
+    });
+
+    test('different content produces different hash', () => {
+      const hash1 = CompressionEngine.hash('content 1');
+      const hash2 = CompressionEngine.hash('content 2');
+      expect(hash1).not.toBe(hash2);
+    });
+
+    test('hash is deterministic', () => {
+      const hashes = new Set();
+      for (let i = 0; i < 10; i++) {
+        hashes.add(CompressionEngine.hash('same content'));
+      }
+      expect(hashes.size).toBe(1);
+    });
+
+    test('produces valid hash format', () => {
+      const hash = CompressionEngine.hash('content');
+      expect(hash).toMatch(/^[a-z0-9]+$/);
+    });
+  });
+
+  describe('Delta Application', () => {
+    test('applies simple delta', () => {
+      const base = 'line 1\nline 2';
+      // Simulate a delta
+      const result = CompressionEngine.applyDelta(base, '+2:line 3');
+      expect(result).toBeDefined();
+    });
+
+    test('applies multiple changes', () => {
+      const base = 'a\nb\nc';
+      const delta = '-1:b\n+1:x';
+      const result = CompressionEngine.applyDelta(base, delta);
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('Delta Creation', () => {
+    test('creates delta from files', () => {
+      const delta = CompressionEngine.createDelta(
+        'file.ts',
+        'old content',
+        'new content'
+      );
+      expect(delta.path).toBe('file.ts');
+      expect(delta.type).toBe('modify');
+    });
+
+    test('delta includes hashes', () => {
+      const delta = CompressionEngine.createDelta(
+        'file.ts',
+        'old',
+        'new'
+      );
+      expect(delta.hash).toBeDefined();
+      expect(delta.baseHash).toBeDefined();
+    });
+
+    test('delta indicates compression', () => {
+      const delta = CompressionEngine.createDelta(
+        'file.ts',
+        'short',
+        'very long content that might compress well'
+      );
+      expect(typeof delta.compressed).toBe('boolean');
+    });
+  });
+
+  describe('File Set Compression', () => {
+    test('compresses multiple files', () => {
+      const files = new Map([
+        ['file1.ts', 'content 1'],
+        ['file2.ts', 'content 2'],
+        ['file3.ts', 'content 3'],
+      ]);
+      const { deltas, stats } = CompressionEngine.compressFileSet(files);
+      expect(deltas).toHaveLength(3);
+      expect(stats.deltas).toBe(3);
+    });
+
+    test('calculates compression ratio', () => {
+      const files = new Map([
+        ['file.txt', 'x'.repeat(100)],
+      ]);
+      const { stats } = CompressionEngine.compressFileSet(files);
+      expect(stats.ratio).toBeGreaterThan(0);
+    });
+
+    test('estimates size savings', () => {
+      const files = new Map([
+        ['file1.ts', 'a'.repeat(1000)],
+        ['file2.ts', 'b'.repeat(1000)],
+      ]);
+      const { stats } = CompressionEngine.compressFileSet(files);
+      expect(stats.originalSize).toBe(2000);
+      expect(stats.compressedSize).toBeLessThan(stats.originalSize);
+    });
+  });
+
+  describe('Benefit Estimation', () => {
+    test('estimates compression benefit', () => {
+      const { savings, ratio } = CompressionEngine.estimateBenefit(100, 1000);
+      expect(savings).toMatch(/\d+\.\d+%/);
+      expect(ratio).toMatch(/\d+\.\d+x/);
+    });
+
+    test('shows significant savings for typical workloads', () => {
+      const { savings } = CompressionEngine.estimateBenefit(1000, 10000);
+      const savingsNum = parseFloat(savings);
+      expect(savingsNum).toBeGreaterThan(30);
+    });
+  });
+
+  describe('Performance', () => {
+    test('calculates delta for 1000 lines quickly', () => {
+      const old = Array(1000).fill('line').join('\n');
+      const new_ver = old + '\nnew line';
+      const start = Date.now();
+      CompressionEngine.calculateDelta(old, new_ver);
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(50);
+    });
+
+    test('compresses 1MB file reasonably', () => {
+      const content = 'x'.repeat(1000000);
+      const start = Date.now();
+      CompressionEngine.compress(content);
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(500);
+    });
+
+    test('hashes 1000 files quickly', () => {
+      const start = Date.now();
+      for (let i = 0; i < 1000; i++) {
+        CompressionEngine.hash(`content ${i}`);
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(100);
+    });
+  });
+});