@zoebuildsai/trace 1.5.0

package/tests/v1.2/performance-monitoring.test.ts

@@ -0,0 +1,328 @@
+/**
+ * Performance Monitoring Tests
+ * Track operation times and identify bottlenecks
+ */
+
+import { PerformanceMonitoring } from '../../src/performance-monitoring';
+
+describe('PerformanceMonitoring', () => {
+  let monitor: PerformanceMonitoring;
+
+  beforeEach(() => {
+    monitor = new PerformanceMonitoring();
+  });
+
+  describe('Operation Tracking', () => {
+    test('tracks operation time', () => {
+      monitor.startOperation('op1');
+      // Simulate some work
+      const start = Date.now();
+      while (Date.now() - start < 10) {} // Sleep 10ms
+
+      const metric = monitor.endOperation('op1', 'test-operation', 'success');
+      expect(metric.duration).toBeGreaterThanOrEqual(10);
+      expect(metric.operation).toBe('test-operation');
+      expect(metric.status).toBe('success');
+    });
+
+    test('tracks multiple operations', () => {
+      monitor.startOperation('op1');
+      monitor.endOperation('op1', 'operation1', 'success');
+
+      monitor.startOperation('op2');
+      monitor.endOperation('op2', 'operation2', 'success');
+
+      monitor.startOperation('op3');
+      monitor.endOperation('op3', 'operation3', 'success');
+
+      const summary = monitor.getSummary();
+      expect(summary.totalMetrics).toBe(3);
+    });
+
+    test('tracks operation failure', () => {
+      monitor.startOperation('op1');
+      const metric = monitor.endOperation('op1', 'test-operation', 'failure');
+      expect(metric.status).toBe('failure');
+    });
+
+    test('includes metadata', () => {
+      monitor.startOperation('op1');
+      const metric = monitor.endOperation('op1', 'commit', 'success', {
+        files: 5,
+        size: 1024,
+      });
+
+      expect(metric.metadata?.files).toBe(5);
+      expect(metric.metadata?.size).toBe(1024);
+    });
+
+    test('throws on missing timer', () => {
+      expect(() => {
+        monitor.endOperation('nonexistent', 'test', 'success');
+      }).toThrow('No timer found');
+    });
+  });
+
+  describe('Statistics Calculation', () => {
+    test('calculates basic stats', () => {
+      for (let i = 0; i < 10; i++) {
+        monitor.startOperation(`op${i}`);
+        const start = Date.now();
+        while (Date.now() - start < 5) {}
+        monitor.endOperation(`op${i}`, 'test-op', 'success');
+      }
+
+      const stats = monitor.getStats('test-op');
+      expect(stats.count).toBe(10);
+      expect(stats.avgDuration).toBeGreaterThan(0);
+      expect(stats.minDuration).toBeGreaterThan(0);
+      expect(stats.maxDuration).toBeGreaterThanOrEqual(stats.minDuration);
+    });
+
+    test('calculates percentiles', () => {
+      for (let i = 0; i < 100; i++) {
+        monitor.startOperation(`op${i}`);
+        const duration = i % 2 === 0 ? 5 : 50;
+        const start = Date.now();
+        while (Date.now() - start < duration) {}
+        monitor.endOperation(`op${i}`, 'test-op', 'success');
+      }
+
+      const stats = monitor.getStats('test-op');
+      expect(stats.p95Duration).toBeGreaterThanOrEqual(stats.avgDuration);
+      expect(stats.p99Duration).toBeGreaterThanOrEqual(stats.p95Duration);
+    });
+
+    test('calculates failure rate', () => {
+      for (let i = 0; i < 10; i++) {
+        monitor.startOperation(`op${i}`);
+        monitor.endOperation(`op${i}`, 'test-op', i % 2 === 0 ? 'success' : 'failure');
+      }
+
+      const stats = monitor.getStats('test-op');
+      expect(stats.failureRate).toBe(0.5);
+    });
+
+    test('returns zero stats for unknown operation', () => {
+      const stats = monitor.getStats('unknown');
+      expect(stats.count).toBe(0);
+      expect(stats.avgDuration).toBe(0);
+    });
+  });
+
+  describe('Bottleneck Detection', () => {
+    test('identifies slow operations', () => {
+      // Fast operation
+      for (let i = 0; i < 10; i++) {
+        monitor.startOperation(`fast${i}`);
+        const start = Date.now();
+        while (Date.now() - start < 5) {}
+        monitor.endOperation(`fast${i}`, 'fast-op', 'success');
+      }
+
+      // Slow operation
+      for (let i = 0; i < 10; i++) {
+        monitor.startOperation(`slow${i}`);
+        const start = Date.now();
+        while (Date.now() - start < 150) {}
+        monitor.endOperation(`slow${i}`, 'slow-op', 'success');
+      }
+
+      const bottlenecks = monitor.findBottlenecks(100);
+      expect(bottlenecks.some(b => b.operation === 'slow-op')).toBe(true);
+      expect(bottlenecks.some(b => b.operation === 'fast-op')).toBe(false);
+    });
+
+    test('returns empty for no bottlenecks', () => {
+      for (let i = 0; i < 10; i++) {
+        monitor.startOperation(`op${i}`);
+        const start = Date.now();
+        while (Date.now() - start < 5) {}
+        monitor.endOperation(`op${i}`, 'fast-op', 'success');
+      }
+
+      const bottlenecks = monitor.findBottlenecks(100);
+      expect(bottlenecks).toHaveLength(0);
+    });
+  });
+
+  describe('Report Generation', () => {
+    test('generates performance report', () => {
+      for (let i = 0; i < 20; i++) {
+        monitor.startOperation(`op${i}`);
+        const start = Date.now();
+        while (Date.now() - start < 10) {}
+        monitor.endOperation(`op${i}`, 'test-op', 'success');
+      }
+
+      const report = monitor.generateReport();
+      expect(report.totalOperations).toBe(20);
+      expect(report.averageLatency).toBeGreaterThan(0);
+      expect(Array.isArray(report.bottlenecks)).toBe(true);
+      expect(Array.isArray(report.recommendations)).toBe(true);
+    });
+
+    test('generates recommendations for slow operations', () => {
+      for (let i = 0; i < 100; i++) {
+        monitor.startOperation(`op${i}`);
+        const start = Date.now();
+        while (Date.now() - start < 200) {} // Very slow
+        monitor.endOperation(`op${i}`, 'slow-op', 'success');
+      }
+
+      const report = monitor.generateReport();
+      expect(report.recommendations.length).toBeGreaterThan(0);
+      expect(report.recommendations[0]).toContain('slow-op');
+    });
+
+    test('generates recommendations for failures', () => {
+      for (let i = 0; i < 20; i++) {
+        monitor.startOperation(`op${i}`);
+        monitor.endOperation(`op${i}`, 'flaky-op', i % 2 === 0 ? 'success' : 'failure');
+      }
+
+      const report = monitor.generateReport();
+      expect(report.recommendations.some(r => r.includes('failure rate'))).toBe(true);
+    });
+
+    test('generates recommendations for high variance', () => {
+      for (let i = 0; i < 50; i++) {
+        monitor.startOperation(`op${i}`);
+        const start = Date.now();
+        // Alternating between very fast and very slow
+        const duration = i % 2 === 0 ? 5 : 300;
+        while (Date.now() - start < duration) {}
+        monitor.endOperation(`op${i}`, 'variable-op', 'success');
+      }
+
+      const report = monitor.generateReport();
+      expect(report.recommendations.some(r => r.includes('High variance'))).toBe(true);
+    });
+  });
+
+  describe('Report Formatting', () => {
+    test('formats clean report', () => {
+      const report = {
+        timestamp: Date.now(),
+        totalOperations: 100,
+        averageLatency: 45,
+        bottlenecks: [],
+        recommendations: [],
+      };
+
+      const formatted = PerformanceMonitoring.formatReport(report);
+      expect(formatted).toContain('PERFORMANCE REPORT');
+      expect(formatted).toContain('100');
+      expect(formatted).toContain('All operations performing');
+    });
+
+    test('formats report with bottlenecks', () => {
+      const report = {
+        timestamp: Date.now(),
+        totalOperations: 100,
+        averageLatency: 45,
+        bottlenecks: [
+          {
+            operation: 'slow-op',
+            count: 10,
+            avgDuration: 150,
+            minDuration: 140,
+            maxDuration: 160,
+            p95Duration: 158,
+            p99Duration: 159,
+            failureRate: 0,
+          },
+        ],
+        recommendations: ['Consider optimizing slow-op'],
+      };
+
+      const formatted = PerformanceMonitoring.formatReport(report);
+      expect(formatted).toContain('BOTTLENECK(S)');
+      expect(formatted).toContain('slow-op');
+      expect(formatted).toContain('150.00ms');
+      expect(formatted).toContain('RECOMMENDATIONS');
+    });
+  });
+
+  describe('Metrics Management', () => {
+    test('clears metrics', () => {
+      monitor.startOperation('op1');
+      monitor.endOperation('op1', 'test-op', 'success');
+
+      expect(monitor.getSummary().totalMetrics).toBe(1);
+      monitor.clearMetrics();
+      expect(monitor.getSummary().totalMetrics).toBe(0);
+    });
+
+    test('gets summary', () => {
+      for (let i = 0; i < 30; i++) {
+        monitor.startOperation(`op${i}`);
+        monitor.endOperation(`op${i}`, `op-${i % 3}`, 'success');
+      }
+
+      const summary = monitor.getSummary();
+      expect(summary.totalMetrics).toBe(30);
+      expect(summary.uniqueOperations).toBe(3);
+      expect(summary.timeRange.start).toBeGreaterThan(0);
+      expect(summary.timeRange.end).toBeGreaterThanOrEqual(summary.timeRange.start);
+    });
+
+    test('gets all stats', () => {
+      monitor.startOperation('op1');
+      monitor.endOperation('op1', 'read', 'success');
+
+      monitor.startOperation('op2');
+      monitor.endOperation('op2', 'write', 'success');
+
+      monitor.startOperation('op3');
+      monitor.endOperation('op3', 'delete', 'success');
+
+      const allStats = monitor.getAllStats();
+      expect(allStats).toHaveLength(3);
+      expect(allStats.map(s => s.operation).sort()).toEqual(['delete', 'read', 'write']);
+    });
+  });
+
+  describe('Real-world Scenarios', () => {
+    test('monitors agent workflow', () => {
+      // Simulate agent workflow
+      const operations = ['commit', 'push', 'pull', 'merge'];
+
+      for (let cycle = 0; cycle < 10; cycle++) {
+        for (const op of operations) {
+          monitor.startOperation(`${op}-${cycle}`);
+          const start = Date.now();
+          while (Date.now() - start < 20 + Math.random() * 30) {}
+          monitor.endOperation(`${op}-${cycle}`, op, 'success');
+        }
+      }
+
+      const report = monitor.generateReport();
+      expect(report.totalOperations).toBe(40);
+      const stats = monitor.getStats('push');
+      expect(stats.count).toBe(10);
+    });
+
+    test('detects performance regression', () => {
+      // Phase 1: Fast operations
+      for (let i = 0; i < 20; i++) {
+        monitor.startOperation(`old${i}`);
+        const start = Date.now();
+        while (Date.now() - start < 10) {}
+        monitor.endOperation(`old${i}`, 'commit', 'success');
+      }
+
+      // Phase 2: Slow operations (regression)
+      for (let i = 0; i < 20; i++) {
+        monitor.startOperation(`new${i}`);
+        const start = Date.now();
+        while (Date.now() - start < 200) {} // 20x slower
+        monitor.endOperation(`new${i}`, 'commit', 'success');
+      }
+
+      const report = monitor.generateReport();
+      expect(report.bottlenecks.length).toBeGreaterThan(0);
+      expect(report.recommendations.length).toBeGreaterThan(0);
+    });
+  });
+});

package/tests/v1.3/auto-branching.test.ts

@@ -0,0 +1,270 @@
+/**
+ * Auto-Branching Tests
+ * Agent-per-task branch management
+ */
+
+import { AutoBranching } from '../../src/auto-branching';
+
+describe('AutoBranching', () => {
+  let branching: AutoBranching;
+
+  beforeEach(() => {
+    branching = new AutoBranching();
+  });
+
+  describe('Branch Creation', () => {
+    test('creates branch for agent task', () => {
+      const branch = branching.createBranchForTask('agent-a', 'implement-login');
+      expect(branch.name).toBe('agent-a/implement-login');
+      expect(branch.agent).toBe('agent-a');
+      expect(branch.task).toBe('implement-login');
+      expect(branch.isActive).toBe(true);
+    });
+
+    test('normalizes branch names', () => {
+      const branch = branching.createBranchForTask('Agent A', 'Implement Login');
+      expect(branch.name).toBe('agent a/implement login');
+    });
+
+    test('prevents duplicate branches', () => {
+      branching.createBranchForTask('agent-a', 'task1');
+      expect(() => {
+        branching.createBranchForTask('agent-a', 'task1');
+      }).toThrow('already exists');
+    });
+
+    test('tracks parent branch', () => {
+      const branch = branching.createBranchForTask('agent-a', 'feature', 'main', 'abc123');
+      expect(branch.parentBranch).toBe('main');
+      expect(branch.headCommit).toBe('abc123');
+    });
+  });
+
+  describe('Branch Retrieval', () => {
+    test('gets branch by name', () => {
+      const created = branching.createBranchForTask('agent-a', 'task1');
+      const retrieved = branching.getBranch('agent-a/task1');
+      expect(retrieved).toEqual(created);
+    });
+
+    test('returns undefined for unknown branch', () => {
+      const branch = branching.getBranch('unknown');
+      expect(branch).toBeUndefined();
+    });
+
+    test('gets all branches for agent', () => {
+      branching.createBranchForTask('agent-a', 'task1');
+      branching.createBranchForTask('agent-a', 'task2');
+      branching.createBranchForTask('agent-b', 'task1');
+
+      const agentABranches = branching.getAgentBranches('agent-a');
+      expect(agentABranches).toHaveLength(2);
+      expect(agentABranches.every(b => b.agent === 'agent-a')).toBe(true);
+    });
+
+    test('lists all branches', () => {
+      branching.createBranchForTask('agent-a', 'task1');
+      branching.createBranchForTask('agent-b', 'task1');
+      branching.createBranchForTask('agent-c', 'task1');
+
+      const all = branching.listBranches();
+      expect(all).toHaveLength(3);
+    });
+
+    test('filters active branches', () => {
+      const b1 = branching.createBranchForTask('agent-a', 'task1');
+      const b2 = branching.createBranchForTask('agent-b', 'task1');
+
+      branching.mergeBranch('agent-a/task1');
+
+      const active = branching.listBranches(true);
+      expect(active).toHaveLength(1);
+      expect(active[0].name).toBe('agent-b/task1');
+    });
+  });
+
+  describe('Get or Create', () => {
+    test('returns existing branch', () => {
+      const created = branching.createBranchForTask('agent-a', 'task1');
+      const retrieved = branching.getOrCreateBranch('agent-a', 'task1');
+      expect(retrieved).toEqual(created);
+    });
+
+    test('creates if not exists', () => {
+      const branch = branching.getOrCreateBranch('agent-a', 'newtask');
+      expect(branch.name).toBe('agent-a/newtask');
+    });
+  });
+
+  describe('Commit Recording', () => {
+    test('records commit on branch', () => {
+      const branch = branching.createBranchForTask('agent-a', 'task1');
+      branching.recordCommit('agent-a/task1', 'abc123def456');
+
+      const updated = branching.getBranch('agent-a/task1')!;
+      expect(updated.headCommit).toBe('abc123def456');
+    });
+
+    test('throws on unknown branch', () => {
+      expect(() => {
+        branching.recordCommit('unknown', 'abc123');
+      }).toThrow('not found');
+    });
+
+    test('tracks commit count', () => {
+      const branch = branching.createBranchForTask('agent-a', 'task1');
+      branching.recordCommit('agent-a/task1', 'commit1');
+      branching.recordCommit('agent-a/task1', 'commit2');
+      branching.recordCommit('agent-a/task1', 'commit3');
+
+      const stats = branching.getStats();
+      expect(stats.commitsByBranch.get('agent-a/task1')).toBe(3);
+    });
+  });
+
+  describe('Branch Merging', () => {
+    test('marks branch inactive on merge', () => {
+      branching.createBranchForTask('agent-a', 'task1');
+      branching.mergeBranch('agent-a/task1');
+
+      const branch = branching.getBranch('agent-a/task1')!;
+      expect(branch.isActive).toBe(false);
+    });
+
+    test('merge and delete removes from active list', () => {
+      branching.createBranchForTask('agent-a', 'task1');
+      branching.mergeBranchAndDelete('agent-a/task1');
+
+      const active = branching.listBranches(true);
+      expect(active.some(b => b.name === 'agent-a/task1')).toBe(false);
+    });
+  });
+
+  describe('Branch Statistics', () => {
+    test('calculates branch stats', () => {
+      branching.createBranchForTask('agent-a', 'task1');
+      branching.createBranchForTask('agent-a', 'task2');
+      branching.createBranchForTask('agent-b', 'task1');
+
+      const stats = branching.getStats();
+      expect(stats.totalBranches).toBe(3);
+      expect(stats.activeBranches).toBe(3);
+    });
+
+    test('tracks oldest and newest branches', () => {
+      const b1 = branching.createBranchForTask('agent-a', 'task1');
+      // Small delay
+      const b2 = branching.createBranchForTask('agent-b', 'task1');
+
+      const stats = branching.getStats();
+      expect(stats.oldestBranch?.name).toBe('agent-a/task1');
+      expect(stats.newestBranch?.name).toBe('agent-b/task1');
+    });
+  });
+
+  describe('Stale Branch Detection', () => {
+    test('detects stale branches', () => {
+      const b1 = branching.createBranchForTask('agent-a', 'old-task');
+      
+      // Manually set last modified to 8 days ago
+      b1.lastModified = Date.now() - 8 * 24 * 60 * 60 * 1000;
+
+      branching.createBranchForTask('agent-b', 'new-task');
+
+      const stale = branching.detectStaleBranches(7);
+      expect(stale).toHaveLength(1);
+      expect(stale[0].name).toBe('agent-a/old-task');
+    });
+
+    test('ignores merged branches', () => {
+      const branch = branching.createBranchForTask('agent-a', 'task1');
+      branch.lastModified = Date.now() - 8 * 24 * 60 * 60 * 1000;
+      branching.mergeBranch('agent-a/task1');
+
+      const stale = branching.detectStaleBranches(7);
+      expect(stale).toHaveLength(0);
+    });
+  });
+
+  describe('Branch Tree', () => {
+    test('builds branch hierarchy', () => {
+      branching.createBranchForTask('agent-a', 'feature', 'main');
+      branching.createBranchForTask('agent-b', 'fix', 'main');
+      branching.createBranchForTask('agent-c', 'nested', 'agent-a/feature');
+
+      const tree = branching.getBranchTree();
+      expect(tree.get('main')).toHaveLength(2);
+      expect(tree.get('agent-a/feature')).toHaveLength(1);
+    });
+  });
+
+  describe('Branch Rebase', () => {
+    test('rebases branch to new parent', () => {
+      const child = branching.createBranchForTask('agent-a', 'feature', 'main');
+      const newParent = branching.createBranchForTask('agent-b', 'develop', 'main');
+
+      branching.rebaseBranch('agent-a/feature', 'agent-b/develop');
+
+      const updated = branching.getBranch('agent-a/feature')!;
+      expect(updated.parentBranch).toBe('agent-b/develop');
+    });
+
+    test('throws on unknown target parent', () => {
+      branching.createBranchForTask('agent-a', 'feature', 'main');
+
+      expect(() => {
+        branching.rebaseBranch('agent-a/feature', 'unknown');
+      }).toThrow('Parent branch');
+    });
+  });
+
+  describe('Formatting', () => {
+    test('formats branch list', () => {
+      const b1 = branching.createBranchForTask('agent-a', 'task1');
+      branching.recordCommit('agent-a/task1', 'abc123');
+
+      const formatted = AutoBranching.formatBranchList([b1]);
+      expect(formatted).toContain('agent-a/task1');
+      expect(formatted).toContain('abc123');
+    });
+
+    test('handles empty list', () => {
+      const formatted = AutoBranching.formatBranchList([]);
+      expect(formatted).toContain('No branches');
+    });
+  });
+
+  describe('Real-world Scenarios', () => {
+    test('manages parallel agent tasks', () => {
+      // 5 agents, 3 tasks each
+      for (let a = 1; a <= 5; a++) {
+        for (let t = 1; t <= 3; t++) {
+          branching.createBranchForTask(`agent-${a}`, `task-${t}`);
+        }
+      }
+
+      const stats = branching.getStats();
+      expect(stats.totalBranches).toBe(15);
+
+      const agent1Tasks = branching.getAgentBranches('agent-1');
+      expect(agent1Tasks).toHaveLength(3);
+    });
+
+    test('handles task completion flow', () => {
+      // Agent creates and works on branch
+      const branch = branching.createBranchForTask('agent-a', 'implement-auth');
+      branching.recordCommit('agent-a/implement-auth', 'commit1');
+      branching.recordCommit('agent-a/implement-auth', 'commit2');
+
+      // Task complete
+      branching.mergeBranch('agent-a/implement-auth');
+
+      // Agent moves to new task
+      const newBranch = branching.createBranchForTask('agent-a', 'fix-bug-123');
+
+      const stats = branching.getStats();
+      expect(stats.activeBranches).toBe(1);
+      expect(branching.getAgentBranches('agent-a')).toHaveLength(2);
+    });
+  });
+});