@zoebuildsai/trace 1.5.0

package/tests/v1.1/agent-audit.test.ts

@@ -0,0 +1,472 @@
+/**
+ * Agent Audit Tests (TDD)
+ * Collision detection, audit trails, conflict resolution
+ */
+
+import { AgentAudit, AuditEntry, FileConflict } from '../../src/agent-audit';
+
+describe('AgentAudit', () => {
+  let audit: AgentAudit;
+
+  beforeEach(() => {
+    audit = new AgentAudit();
+  });
+
+  describe('Commit Recording', () => {
+    test('should record commit from agent', () => {
+      const entry = {
+        commitId: 'commit-1',
+        agentId: 'agent-a',
+        agentName: 'Agent Alpha',
+        files: ['src/feature.ts'],
+        message: 'Add feature',
+        signature: 'sig-1',
+      };
+
+      audit.recordCommit(entry);
+      const history = audit.getAgentHistory('agent-a');
+
+      expect(history).toHaveLength(1);
+      expect(history[0].agentId).toBe('agent-a');
+    });
+
+    test('should track file ownership', () => {
+      audit.recordCommit({
+        commitId: 'commit-1',
+        agentId: 'agent-a',
+        agentName: 'Agent Alpha',
+        files: ['src/file.ts'],
+        message: 'Edit file',
+        signature: 'sig-1',
+      });
+
+      const fileHistory = audit.getFileHistory('src/file.ts');
+      expect(fileHistory).toHaveLength(1);
+      expect(fileHistory[0].agentId).toBe('agent-a');
+    });
+
+    test('should handle multiple commits from same agent', () => {
+      for (let i = 0; i < 5; i++) {
+        audit.recordCommit({
+          commitId: `commit-${i}`,
+          agentId: 'agent-a',
+          agentName: 'Agent Alpha',
+          files: [`src/file${i}.ts`],
+          message: `Edit ${i}`,
+          signature: `sig-${i}`,
+        });
+      }
+
+      const history = audit.getAgentHistory('agent-a');
+      expect(history).toHaveLength(5);
+    });
+  });
+
+  describe('Collision Detection', () => {
+    test('should detect collision when multiple agents edit same file', () => {
+      audit.recordCommit({
+        commitId: 'commit-1',
+        agentId: 'agent-a',
+        agentName: 'Agent Alpha',
+        files: ['src/shared.ts'],
+        message: 'Agent A edits',
+        signature: 'sig-1',
+      });
+
+      const collision = audit.detectCollisions('src/shared.ts', ['agent-a', 'agent-b']);
+
+      expect(collision).not.toBeNull();
+      expect(collision?.agents).toContain('agent-a');
+      expect(collision?.agents).toContain('agent-b');
+    });
+
+    test('should not report collision for single agent', () => {
+      audit.recordCommit({
+        commitId: 'commit-1',
+        agentId: 'agent-a',
+        agentName: 'Agent Alpha',
+        files: ['src/file.ts'],
+        message: 'Edit',
+        signature: 'sig-1',
+      });
+
+      const collision = audit.detectCollisions('src/file.ts', ['agent-a']);
+
+      expect(collision).toBeNull();
+    });
+
+    test('should track collision metadata', () => {
+      audit.recordCommit({
+        commitId: 'commit-1',
+        agentId: 'agent-a',
+        agentName: 'Agent Alpha',
+        files: ['shared.ts'],
+        message: 'Edit',
+        signature: 'sig-1',
+      });
+
+      const collision = audit.detectCollisions('shared.ts', ['agent-b', 'agent-c']);
+
+      expect(collision?.path).toBe('shared.ts');
+      expect(collision?.lastModifiedBy).toBe('agent-a');
+      expect(collision?.resolution).toBe('pending');
+    });
+  });
+
+  describe('Audit Trail', () => {
+    test('should show full history of file edits', () => {
+      const file = 'src/important.ts';
+
+      audit.recordCommit({
+        commitId: 'commit-1',
+        agentId: 'agent-a',
+        agentName: 'Agent Alpha',
+        files: [file],
+        message: 'Initial',
+        signature: 'sig-1',
+      });
+
+      audit.recordCommit({
+        commitId: 'commit-2',
+        agentId: 'agent-b',
+        agentName: 'Agent Beta',
+        files: [file],
+        message: 'Update',
+        signature: 'sig-2',
+      });
+
+      audit.recordCommit({
+        commitId: 'commit-3',
+        agentId: 'agent-a',
+        agentName: 'Agent Alpha',
+        files: [file],
+        message: 'Final',
+        signature: 'sig-3',
+      });
+
+      const history = audit.getFileHistory(file);
+
+      expect(history).toHaveLength(3);
+      expect(history[0].agentId).toBe('agent-a');
+      expect(history[1].agentId).toBe('agent-b');
+      expect(history[2].agentId).toBe('agent-a');
+    });
+
+    test('should identify last editor', () => {
+      audit.recordCommit({
+        commitId: 'c1',
+        agentId: 'agent-a',
+        agentName: 'A',
+        files: ['file.ts'],
+        message: 'm1',
+        signature: 's1',
+      });
+
+      audit.recordCommit({
+        commitId: 'c2',
+        agentId: 'agent-b',
+        agentName: 'B',
+        files: ['file.ts'],
+        message: 'm2',
+        signature: 's2',
+      });
+
+      const history = audit.getFileHistory('file.ts');
+      const lastEditor = history[history.length - 1].agentId;
+
+      expect(lastEditor).toBe('agent-b');
+    });
+  });
+
+  describe('Conflict Resolution', () => {
+    test('should resolve using timestamp priority', () => {
+      const file = 'conflict.ts';
+
+      audit.recordCommit({
+        commitId: 'c1',
+        agentId: 'agent-a',
+        agentName: 'A',
+        files: [file],
+        message: 'm',
+        signature: 's',
+      });
+
+      const resolution = audit.resolveConflict(
+        file,
+        'agent-a',
+        'agent-b',
+        'timestamp-priority'
+      );
+
+      expect(resolution.result).toBe('resolved');
+      expect(resolution.strategy).toBe('timestamp-priority');
+    });
+
+    test('should resolve using agent priority', () => {
+      const resolution = audit.resolveConflict(
+        'file.ts',
+        'agent-z',
+        'agent-a',
+        'agent-priority'
+      );
+
+      expect(resolution.result).toBe('resolved');
+      expect(resolution.strategy).toBe('agent-priority');
+    });
+
+    test('should flag manual merge as requires-review', () => {
+      const resolution = audit.resolveConflict(
+        'complex.ts',
+        'agent-a',
+        'agent-b',
+        'manual-merge'
+      );
+
+      expect(resolution.result).toBe('requires-review');
+    });
+
+    test('should suggest merge strategy based on history', () => {
+      for (let i = 0; i < 5; i++) {
+        audit.recordCommit({
+          commitId: `c${i}`,
+          agentId: 'agent-a',
+          agentName: 'A',
+          files: ['file.ts'],
+          message: 'm',
+          signature: 's',
+        });
+      }
+
+      audit.recordCommit({
+        commitId: 'c6',
+        agentId: 'agent-b',
+        agentName: 'B',
+        files: ['file.ts'],
+        message: 'm',
+        signature: 's',
+      });
+
+      const suggested = audit.suggestMergeStrategy('file.ts', 'agent-a', 'agent-b');
+
+      expect(suggested).toBe('agent-priority');
+    });
+  });
+
+  describe('Audit Report', () => {
+    test('should generate comprehensive audit report', () => {
+      audit.recordCommit({
+        commitId: 'c1',
+        agentId: 'agent-a',
+        agentName: 'Alpha',
+        files: ['src/a.ts', 'src/b.ts'],
+        message: 'Two files',
+        signature: 's1',
+      });
+
+      audit.recordCommit({
+        commitId: 'c2',
+        agentId: 'agent-b',
+        agentName: 'Beta',
+        files: ['src/c.ts'],
+        message: 'One file',
+        signature: 's2',
+      });
+
+      const report = audit.generateAuditReport();
+
+      expect(report.totalCommits).toBe(2);
+      expect(report.agentCount).toBe(2);
+      expect((report.agents as any)['agent-a'].commits).toBe(1);
+      expect((report.agents as any)['agent-b'].commits).toBe(1);
+    });
+
+    test('should show files changed per agent', () => {
+      audit.recordCommit({
+        commitId: 'c1',
+        agentId: 'agent-a',
+        agentName: 'A',
+        files: ['f1.ts', 'f2.ts', 'f3.ts'],
+        message: 'm',
+        signature: 's',
+      });
+
+      const report = audit.generateAuditReport();
+      const agentStats = (report.agents as any)['agent-a'];
+
+      expect(agentStats.filesChanged).toHaveLength(3);
+    });
+  });
+
+  describe('File Locking', () => {
+    test('should allow locking new file', () => {
+      const canLock = audit.lockFile('new-file.ts', 'agent-a');
+
+      expect(canLock).toBe(true);
+    });
+
+    test('should prevent lock if recently edited', () => {
+      audit.recordCommit({
+        commitId: 'c1',
+        agentId: 'agent-a',
+        agentName: 'A',
+        files: ['file.ts'],
+        message: 'm',
+        signature: 's',
+      });
+
+      const canLock = audit.lockFile('file.ts', 'agent-b', 30000);
+
+      expect(canLock).toBe(false);
+    });
+
+    test('should allow lock after timeout', (done) => {
+      audit.recordCommit({
+        commitId: 'c1',
+        agentId: 'agent-a',
+        agentName: 'A',
+        files: ['file.ts'],
+        message: 'm',
+        signature: 's',
+      });
+
+      setTimeout(() => {
+        const canLock = audit.lockFile('file.ts', 'agent-b', 10); // 10ms timeout
+
+        expect(canLock).toBe(true);
+        done();
+      }, 50);
+    });
+  });
+
+  describe('Signature Verification', () => {
+    test('should verify valid signature', () => {
+      audit.recordCommit({
+        commitId: 'commit-1',
+        agentId: 'agent-a',
+        agentName: 'A',
+        files: ['file.ts'],
+        message: 'm',
+        signature: 'valid-sig',
+      });
+
+      const isValid = audit.verifySignature('commit-1', 'valid-sig', 'pubkey');
+
+      expect(isValid).toBe(true);
+    });
+
+    test('should reject invalid signature', () => {
+      audit.recordCommit({
+        commitId: 'commit-1',
+        agentId: 'agent-a',
+        agentName: 'A',
+        files: ['file.ts'],
+        message: 'm',
+        signature: 'valid-sig',
+      });
+
+      const isValid = audit.verifySignature('commit-1', 'wrong-sig', 'pubkey');
+
+      expect(isValid).toBe(false);
+    });
+
+    test('should reject unknown commit', () => {
+      const isValid = audit.verifySignature('unknown', 'sig', 'pubkey');
+
+      expect(isValid).toBe(false);
+    });
+  });
+
+  describe('Statistics', () => {
+    test('should calculate accurate statistics', () => {
+      for (let i = 0; i < 3; i++) {
+        audit.recordCommit({
+          commitId: `c${i}`,
+          agentId: `agent-${i % 2}`,
+          agentName: `Agent ${i % 2}`,
+          files: [`file${i}-1.ts`, `file${i}-2.ts`],
+          message: 'm',
+          signature: 's',
+        });
+      }
+
+      const stats = audit.getStats();
+
+      expect(stats.totalCommits).toBe(3);
+      expect(stats.uniqueAgents).toBe(2);
+      expect(stats.uniqueFiles).toBe(6);
+    });
+
+    test('should calculate average commit size', () => {
+      audit.recordCommit({
+        commitId: 'c1',
+        agentId: 'a',
+        agentName: 'A',
+        files: ['f1.ts', 'f2.ts'],
+        message: 'm',
+        signature: 's',
+      });
+
+      audit.recordCommit({
+        commitId: 'c2',
+        agentId: 'a',
+        agentName: 'A',
+        files: ['f3.ts', 'f4.ts', 'f5.ts'],
+        message: 'm',
+        signature: 's',
+      });
+
+      const stats = audit.getStats();
+
+      expect(stats.averageCommitSize).toBe(2.5);
+    });
+  });
+
+  describe('Multi-Agent Scenarios', () => {
+    test('should track parallel edits from multiple agents', () => {
+      const agents = ['agent-1', 'agent-2', 'agent-3'];
+
+      agents.forEach((agent, i) => {
+        audit.recordCommit({
+          commitId: `c${i}`,
+          agentId: agent,
+          agentName: `Agent ${i}`,
+          files: [`file${i}.ts`],
+          message: `Edit by ${agent}`,
+          signature: `sig${i}`,
+        });
+      });
+
+      const report = audit.generateAuditReport();
+
+      expect(report.agentCount).toBe(3);
+      expect(report.totalCommits).toBe(3);
+    });
+
+    test('should handle agent editing different files', () => {
+      audit.recordCommit({
+        commitId: 'c1',
+        agentId: 'agent-a',
+        agentName: 'A',
+        files: ['a.ts', 'b.ts'],
+        message: 'm',
+        signature: 's',
+      });
+
+      audit.recordCommit({
+        commitId: 'c2',
+        agentId: 'agent-b',
+        agentName: 'B',
+        files: ['c.ts', 'd.ts'],
+        message: 'm',
+        signature: 's',
+      });
+
+      const report = audit.generateAuditReport();
+      const aStats = (report.agents as any)['agent-a'];
+      const bStats = (report.agents as any)['agent-b'];
+
+      expect(aStats.filesChanged).toHaveLength(2);
+      expect(bStats.filesChanged).toHaveLength(2);
+    });
+  });
+});