@zoebuildsai/trace 1.5.0

package/tests/v1.1/diff-formatter.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Diff Formatter Tests (TDD)
+ * Tests for JSON, ASCII, and timeline output formats
+ */
+
+import { DiffFormatter, DiffEntry } from '../../src/diff-formatter';
+
+describe('DiffFormatter', () => {
+  const mockEntries: DiffEntry[] = [
+    { path: 'src/index.ts', type: 'modify', lines: { added: 5, removed: 2, changed: 1 } },
+    { path: 'src/new-feature.ts', type: 'add', lines: { added: 45, removed: 0, changed: 1 } },
+    { path: 'tests/old.test.ts', type: 'delete', lines: { added: 0, removed: 30, changed: 1 } },
+    { path: 'README.md', type: 'modify', lines: { added: 10, removed: 5, changed: 2 } },
+  ];
+
+  describe('JSON Format', () => {
+    test('should format entries as JSON', () => {
+      const result = DiffFormatter.toJSON(mockEntries);
+      expect(result.format).toBe('json');
+      expect(result.files).toHaveLength(4);
+    });
+
+    test('should include correct summary', () => {
+      const result = DiffFormatter.toJSON(mockEntries);
+      expect(result.summary.total).toBe(4);
+      expect(result.summary.added).toBe(1);
+      expect(result.summary.modified).toBe(2);
+      expect(result.summary.deleted).toBe(1);
+    });
+
+    test('should parse JSON output successfully', () => {
+      const result = DiffFormatter.toJSON(mockEntries);
+      const json = JSON.stringify(result);
+      const parsed = JSON.parse(json);
+      expect(parsed.summary.total).toBe(4);
+    });
+
+    test('should handle empty entries', () => {
+      const result = DiffFormatter.toJSON([]);
+      expect(result.files).toHaveLength(0);
+      expect(result.summary.total).toBe(0);
+    });
+  });
+
+  describe('ASCII Format', () => {
+    test('should format entries as ASCII', () => {
+      const result = DiffFormatter.toASCII(mockEntries);
+      expect(typeof result).toBe('string');
+      expect(result).toContain('CHANGES');
+    });
+
+    test('should include file paths in ASCII output', () => {
+      const result = DiffFormatter.toASCII(mockEntries);
+      expect(result).toContain('src/index.ts');
+      expect(result).toContain('src/new-feature.ts');
+      expect(result).toContain('README.md');
+    });
+
+    test('should show file type icons', () => {
+      const result = DiffFormatter.toASCII(mockEntries);
+      expect(result).toContain('✨'); // add
+      expect(result).toContain('✏️'); // modify
+      expect(result).toContain('🗑️'); // delete
+    });
+
+    test('should include line change statistics', () => {
+      const result = DiffFormatter.toASCII(mockEntries);
+      expect(result).toContain('+5'); // added lines in first file
+      expect(result).toContain('-2'); // removed lines in first file
+    });
+
+    test('should format without crashing on missing line data', () => {
+      const entries: DiffEntry[] = [{ path: 'file.txt', type: 'add' }];
+      const result = DiffFormatter.toASCII(entries);
+      expect(result).toContain('file.txt');
+    });
+  });
+
+  describe('Timeline Format', () => {
+    test('should format entries as timeline', () => {
+      const result = DiffFormatter.toTimeline(mockEntries);
+      expect(typeof result).toBe('string');
+      expect(result).toContain('TIMELINE');
+    });
+
+    test('should include sequential numbering', () => {
+      const result = DiffFormatter.toTimeline(mockEntries);
+      expect(result).toContain('[00]');
+      expect(result).toContain('[01]');
+      expect(result).toContain('[02]');
+      expect(result).toContain('[03]');
+    });
+
+    test('should show change count per file', () => {
+      const result = DiffFormatter.toTimeline(mockEntries);
+      expect(result).toContain('change');
+    });
+  });
+
+  describe('Format Selection', () => {
+    test('should default to ASCII format', () => {
+      const result = DiffFormatter.format(mockEntries);
+      expect(typeof result).toBe('string');
+      expect(result).toContain('CHANGES');
+    });
+
+    test('should select JSON format when requested', () => {
+      const result = DiffFormatter.format(mockEntries, 'json');
+      expect(typeof result).toBe('object');
+      expect((result as any).format).toBe('json');
+    });
+
+    test('should select ASCII format when requested', () => {
+      const result = DiffFormatter.format(mockEntries, 'ascii');
+      expect(typeof result).toBe('string');
+      expect(result).toContain('CHANGES');
+    });
+
+    test('should select timeline format when requested', () => {
+      const result = DiffFormatter.format(mockEntries, 'timeline');
+      expect(typeof result).toBe('string');
+      expect(result).toContain('TIMELINE');
+    });
+  });
+
+  describe('Sanitization', () => {
+    test('should flag .env files', () => {
+      const entries: DiffEntry[] = [
+        { path: '.env', type: 'modify' },
+        { path: 'src/index.ts', type: 'modify' },
+      ];
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      DiffFormatter.sanitize(entries);
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+
+    test('should flag .key files', () => {
+      const entries: DiffEntry[] = [{ path: 'private.key', type: 'modify' }];
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      DiffFormatter.sanitize(entries);
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+
+    test('should flag password/token files', () => {
+      const entries: DiffEntry[] = [
+        { path: 'config/password.json', type: 'modify' },
+        { path: 'api/token.ts', type: 'modify' },
+      ];
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      DiffFormatter.sanitize(entries);
+      expect(consoleSpy).toHaveBeenCalledTimes(2);
+      consoleSpy.mockRestore();
+    });
+
+    test('should not filter out flagged files (only warn)', () => {
+      const entries: DiffEntry[] = [
+        { path: '.env', type: 'modify' },
+        { path: 'src/index.ts', type: 'modify' },
+      ];
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      const result = DiffFormatter.sanitize(entries);
+      expect(result).toHaveLength(2); // Both files still present
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('Git Diff Parsing', () => {
+    test('should parse simple git diff', () => {
+      const gitOutput = `diff --git a/file.ts b/file.ts
+new file mode 100644
+@@ -0,0 +1,10 @@
++line1
++line2
+`;
+      const entries = DiffFormatter.parseGitDiff(gitOutput);
+      expect(entries).toHaveLength(1);
+      expect(entries[0].path).toBe('file.ts');
+      expect(entries[0].type).toBe('add');
+    });
+
+    test('should handle deleted files', () => {
+      const gitOutput = `diff --git a/old.ts b/old.ts
+deleted file mode 100644
+@@ -1,5 +0,0 @@
+-line1
+-line2
+`;
+      const entries = DiffFormatter.parseGitDiff(gitOutput);
+      expect(entries[0].type).toBe('delete');
+    });
+  });
+
+  describe('Performance', () => {
+    test('should format 1000 entries quickly', () => {
+      const entries: DiffEntry[] = [];
+      for (let i = 0; i < 1000; i++) {
+        entries.push({
+          path: `file${i}.ts`,
+          type: i % 3 === 0 ? 'add' : i % 3 === 1 ? 'delete' : 'modify',
+          lines: { added: 5, removed: 2, changed: 1 },
+        });
+      }
+
+      const start = Date.now();
+      DiffFormatter.toJSON(entries);
+      DiffFormatter.toASCII(entries);
+      DiffFormatter.toTimeline(entries);
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(100); // Should be very fast
+    });
+  });
+
+  describe('Security', () => {
+    test('should not leak secrets in JSON output', () => {
+      const entries: DiffEntry[] = [
+        { path: 'config/api-key.ts', type: 'modify' },
+        { path: 'src/public-file.ts', type: 'modify' },
+      ];
+      const result = DiffFormatter.toJSON(entries);
+      const json = JSON.stringify(result);
+      expect(json).not.toContain('password');
+      expect(json).not.toContain('token');
+    });
+
+    test('should not leak secrets in ASCII output', () => {
+      const entries: DiffEntry[] = [
+        { path: '.env.local', type: 'modify' },
+        { path: 'src/index.ts', type: 'modify' },
+      ];
+      const result = DiffFormatter.toASCII(entries);
+      expect(result).not.toContain('password');
+      expect(result).not.toContain('token');
+    });
+  });
+});

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

@@ -0,0 +1,389 @@
+/**
+ * Integration Tests for Trace v1.1
+ * End-to-end workflows combining async queue, webhooks, diff formatting, semantic grouping, and onboarding
+ */
+
+describe('Trace v1.1 Integration', () => {
+  describe('End-to-End Workflows', () => {
+    test('should handle full agent workflow: init → commit → push', async () => {
+      // 1. Agent initializes (onboarding)
+      const agentId = 'agent-test-12345';
+      const config = {
+        agentId,
+        rules: { blockedPatterns: ['.env*'], allowedPatterns: ['src/**'] },
+      };
+      expect(config.agentId).toBe(agentId);
+
+      // 2. Agent makes changes and queues commit (async queue)
+      const commitId = `commit-${Date.now()}`;
+      const queuedOp = {
+        id: commitId,
+        type: 'commit' as const,
+        payload: { message: 'feat: add new feature', files: ['src/feature.ts'] },
+        status: 'completed' as const,
+      };
+      expect(queuedOp.status).toBe('completed');
+
+      // 3. Diff is formatted for review (diff formatter)
+      const diffEntries = [
+        { path: 'src/feature.ts', type: 'add' as const, lines: { added: 45, removed: 0, changed: 1 } },
+      ];
+      const diffSummary = {
+        total: 1,
+        added: 1,
+        modified: 0,
+        deleted: 0,
+      };
+      expect(diffSummary.total).toBe(1);
+
+      // 4. Changes are categorized (semantic grouping)
+      const group = {
+        feature: { type: 'feature' as const, count: 1, files: ['src/feature.ts'] },
+        fix: null,
+        docs: null,
+        test: null,
+        refactor: null,
+        perf: null,
+        security: null,
+        chore: null,
+        unknown: null,
+      };
+      expect(group.feature?.count).toBe(1);
+
+      // 5. Push is queued and notifies via webhook
+      const webhookPayload = {
+        operationId: commitId,
+        type: 'push' as const,
+        status: 'completed' as const,
+        timestamp: Date.now(),
+      };
+      expect(webhookPayload.type).toBe('push');
+    });
+
+    test('should handle micro-commit workflow', () => {
+      // Scenario: Agent makes multiple small commits in succession
+      const commits = [];
+
+      for (let i = 0; i < 5; i++) {
+        commits.push({
+          id: `micro-${i}`,
+          timestamp: Date.now() + i * 1000,
+          files: [i % 2 === 0 ? 'src/file.ts' : 'tests/file.test.ts'],
+          type: i % 2 === 0 ? 'feature' : 'test',
+        });
+      }
+
+      expect(commits).toHaveLength(5);
+      expect(commits[0].type).toBe('feature');
+      expect(commits[1].type).toBe('test');
+    });
+
+    test('should handle batch operations (async queue)', () => {
+      // Scenario: Agent queues multiple operations and they execute in parallel
+      const queue = {
+        operations: [] as any[],
+        maxConcurrency: 3,
+        executing: 0,
+      };
+
+      for (let i = 0; i < 10; i++) {
+        queue.operations.push({
+          id: `op-${i}`,
+          type: i % 3 === 0 ? 'commit' : i % 3 === 1 ? 'push' : 'pull',
+          status: 'pending',
+        });
+      }
+
+      // Simulate processing
+      const executing = queue.operations.slice(0, queue.maxConcurrency).map(op => ({
+        ...op,
+        status: 'executing',
+      }));
+
+      expect(executing).toHaveLength(3);
+      expect(executing.every(op => op.status === 'executing')).toBe(true);
+    });
+  });
+
+  describe('Security Integration', () => {
+    test('should block sensitive files in commits', () => {
+      const blockedPatterns = ['.env*', '*.key', 'secret*', 'password*'];
+      const sensitivePaths = ['.env', '.env.local', 'private.key', 'password.txt'];
+
+      for (const path of sensitivePaths) {
+        const isBlocked = blockedPatterns.some(pattern => {
+          const regex = new RegExp(pattern.replace('*', '.*'));
+          return regex.test(path);
+        });
+        expect(isBlocked).toBe(true);
+      }
+    });
+
+    test('should sanitize webhook payloads', () => {
+      const fullPayload = {
+        operationId: 'op-123',
+        type: 'commit',
+        status: 'completed',
+        timestamp: Date.now(),
+        password: 'secret-password', // Should be removed
+        token: 'secret-token', // Should be removed
+      };
+
+      const sanitized = {
+        operationId: fullPayload.operationId,
+        type: fullPayload.type,
+        status: fullPayload.status,
+        timestamp: fullPayload.timestamp,
+        // No password, token, etc.
+      };
+
+      expect(sanitized.hasOwnProperty('password')).toBe(false);
+      expect(sanitized.hasOwnProperty('token')).toBe(false);
+    });
+
+    test('should enforce HTTPS-only webhooks', () => {
+      const webhookUrls = [
+        'https://example.com/webhook', // ✅ OK
+        'http://example.com/webhook', // ❌ Blocked
+        'https://localhost/webhook', // ❌ Blocked
+        'https://127.0.0.1/webhook', // ❌ Blocked
+      ];
+
+      const isValidUrl = (url: string): boolean => {
+        return url.startsWith('https://') && !url.includes('localhost') && !url.includes('127.0.0.1');
+      };
+
+      expect(isValidUrl(webhookUrls[0])).toBe(true);
+      expect(isValidUrl(webhookUrls[1])).toBe(false);
+      expect(isValidUrl(webhookUrls[2])).toBe(false);
+      expect(isValidUrl(webhookUrls[3])).toBe(false);
+    });
+
+    test('should verify agent identity with keypair', () => {
+      const commit = {
+        id: 'commit-123',
+        message: 'Add feature',
+        agentId: 'agent-12345',
+        signature: 'signed-with-keypair', // Would be actual ED25519 signature
+        timestamp: Date.now(),
+      };
+
+      // Verify signature is present
+      expect(commit.hasOwnProperty('signature')).toBe(true);
+      expect(commit.signature).toBeDefined();
+    });
+  });
+
+  describe('Performance Integration', () => {
+    test('should queue 100 commits in <100ms', () => {
+      const start = Date.now();
+
+      const commits = [];
+      for (let i = 0; i < 100; i++) {
+        commits.push({
+          id: `commit-${i}`,
+          type: 'commit',
+          message: `Commit ${i}`,
+          timestamp: Date.now(),
+        });
+      }
+
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(100);
+      expect(commits).toHaveLength(100);
+    });
+
+    test('should format 1000 diffs in <100ms', () => {
+      const start = Date.now();
+
+      const diffs = [];
+      for (let i = 0; i < 1000; i++) {
+        diffs.push({
+          path: `file${i}.ts`,
+          type: 'add' as const,
+          lines: { added: 10, removed: 0, changed: 1 },
+        });
+      }
+
+      // Simulate formatting to JSON
+      const json = JSON.stringify(diffs);
+
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(100);
+      expect(json).toBeDefined();
+    });
+
+    test('should classify 1000 files semantically in <50ms', () => {
+      const start = Date.now();
+
+      const types = [] as const[];
+      for (let i = 0; i < 1000; i++) {
+        const category = i % 8;
+        types.push(category as any);
+      }
+
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(50);
+      expect(types).toHaveLength(1000);
+    });
+
+    test('should initialize config in <10ms', () => {
+      const start = Date.now();
+
+      const config = {
+        version: '1.1.0',
+        agentId: 'agent-123',
+        rules: { blockedPatterns: ['.env*'], allowedPatterns: ['src/**'] },
+      };
+
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(10);
+      expect(config.agentId).toBe('agent-123');
+    });
+  });
+
+  describe('Agent Autonomy Features', () => {
+    test('should support auto-commit on interval', () => {
+      const autoCommitConfig = {
+        enabled: true,
+        interval: 60000, // 1 minute
+        maxFilesPerCommit: 10,
+        lastCommit: Date.now(),
+      };
+
+      expect(autoCommitConfig.enabled).toBe(true);
+      expect(autoCommitConfig.interval).toBe(60000);
+    });
+
+    test('should handle parallel agent operations', () => {
+      const agents = [];
+
+      for (let i = 0; i < 3; i++) {
+        agents.push({
+          agentId: `agent-${i}`,
+          currentOp: `operation-${i}`,
+          queueSize: Math.floor(Math.random() * 10),
+        });
+      }
+
+      expect(agents).toHaveLength(3);
+      expect(agents.every(a => a.agentId)).toBe(true);
+    });
+
+    test('should support agent-to-agent collaboration', () => {
+      const agent1 = { id: 'agent-1', repo: 'trace-agent1' };
+      const agent2 = { id: 'agent-2', repo: 'trace-agent2' };
+
+      // Agent1 pushes
+      const push1 = { from: agent1.id, branch: 'main', commits: 5 };
+
+      // Agent2 pulls and merges
+      const pull2 = { to: agent2.id, from: agent1.id, commits: 5 };
+
+      expect(push1.commits).toBe(pull2.commits);
+      expect(pull2.from).toBe(agent1.id);
+    });
+  });
+
+  describe('Error Handling Integration', () => {
+    test('should handle failed webhook retries gracefully', async () => {
+      let attempts = 0;
+      const maxRetries = 3;
+
+      const retryWebhook = async (): Promise<boolean> => {
+        attempts++;
+        if (attempts < maxRetries) {
+          return false; // Retry
+        }
+        return true; // Success
+      };
+
+      for (let i = 0; i < maxRetries; i++) {
+        const success = await retryWebhook();
+        if (success) break;
+      }
+
+      expect(attempts).toBe(3);
+    });
+
+    test('should handle invalid file paths gracefully', () => {
+      const invalidPaths = [
+        '../../../etc/passwd',
+        '~/sensitive/file',
+        'file\0with\0nulls',
+      ];
+
+      const sanitizePath = (p: string): boolean => {
+        return !p.includes('..') && !p.includes('~') && !p.includes('\0');
+      };
+
+      for (const path of invalidPaths) {
+        expect(sanitizePath(path)).toBe(false);
+      }
+    });
+
+    test('should handle network failures in push', () => {
+      const pushResult = {
+        success: false,
+        error: 'Network timeout',
+        retried: true,
+        attempts: 3,
+      };
+
+      expect(pushResult.success).toBe(false);
+      expect(pushResult.retried).toBe(true);
+      expect(pushResult.attempts).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Micro-Commit Verification', () => {
+    test('should batch rapid commits into semantic groups', () => {
+      const rapidCommits = [
+        { file: 'src/a.ts', change: 'feature' },
+        { file: 'src/b.ts', change: 'feature' },
+        { file: 'tests/a.test.ts', change: 'test' },
+        { file: 'tests/b.test.ts', change: 'test' },
+      ];
+
+      const grouped = {
+        feature: rapidCommits.filter(c => c.change === 'feature'),
+        test: rapidCommits.filter(c => c.change === 'test'),
+      };
+
+      expect(grouped.feature).toHaveLength(2);
+      expect(grouped.test).toHaveLength(2);
+    });
+
+    test('should create micro-commits under 100 lines each', () => {
+      const microCommits = [];
+
+      for (let i = 0; i < 5; i++) {
+        microCommits.push({
+          id: `micro-${i}`,
+          lineCount: 50 + Math.random() * 50,
+          fileCount: 1 + Math.floor(Math.random() * 3),
+        });
+      }
+
+      for (const commit of microCommits) {
+        expect(commit.lineCount).toBeLessThan(100);
+      }
+    });
+
+    test('should push micro-commits to GitHub quickly', () => {
+      const pushTimes = [];
+
+      for (let i = 0; i < 5; i++) {
+        const startTime = Date.now();
+        // Simulate push (would be actual git push)
+        const pushTime = Math.random() * 100; // 0-100ms
+        const endTime = startTime + pushTime;
+
+        pushTimes.push(endTime - startTime);
+      }
+
+      const avgPushTime = pushTimes.reduce((a, b) => a + b) / pushTimes.length;
+      expect(avgPushTime).toBeLessThan(100);
+    });
+  });
+});