claude-mycelium 2.0.0

package/tests/trace/trace-event.test.ts

@@ -0,0 +1,666 @@
+/**
+ * Tests for Trace Event System
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  recordTrace,
+  readTraces,
+  getRecentEfficiency,
+  calculateEfficiency,
+  getTraceStats,
+  generateTraceId,
+  calculateCost,
+  createTraceEvent,
+  type TraceEvent,
+  type Mode,
+} from '../../src/trace/trace-event.js';
+
+const TEST_TRACES_FILE = '.agent-meta/traces.jsonl';
+const TEST_ARCHIVE_DIR = '.agent-meta/traces-archive';
+
+describe('Trace Event System', () => {
+  beforeEach(() => {
+    // Clean up test files
+    if (fs.existsSync(TEST_TRACES_FILE)) {
+      fs.unlinkSync(TEST_TRACES_FILE);
+    }
+    if (fs.existsSync(TEST_ARCHIVE_DIR)) {
+      fs.rmSync(TEST_ARCHIVE_DIR, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    // Clean up after tests
+    if (fs.existsSync(TEST_TRACES_FILE)) {
+      fs.unlinkSync(TEST_TRACES_FILE);
+    }
+    if (fs.existsSync(TEST_ARCHIVE_DIR)) {
+      fs.rmSync(TEST_ARCHIVE_DIR, { recursive: true });
+    }
+  });
+
+  describe('recordTrace', () => {
+    it('should record a trace event to JSONL file', async () => {
+      const trace: TraceEvent = {
+        id: 'test-1',
+        timestamp: new Date().toISOString(),
+        agent_id: 'agent-123',
+        file_path: 'src/test.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.8,
+        gradient_after: 0.6,
+        gradient_delta: 0.2,
+        changes_made: ['fix null check', 'add error handling'],
+        tokens_used: 1000,
+        cost_usd: 0.05,
+        duration_ms: 30000,
+        success: true,
+      };
+
+      await recordTrace(trace);
+
+      expect(fs.existsSync(TEST_TRACES_FILE)).toBe(true);
+      const content = fs.readFileSync(TEST_TRACES_FILE, 'utf-8');
+      const lines = content.trim().split('\n');
+      expect(lines).toHaveLength(1);
+
+      const recorded = JSON.parse(lines[0]);
+      expect(recorded.id).toBe('test-1');
+      expect(recorded.file_path).toBe('src/test.ts');
+    });
+
+    it('should calculate gradient_delta if not provided', async () => {
+      const trace = {
+        id: 'test-2',
+        timestamp: new Date().toISOString(),
+        agent_id: 'agent-456',
+        file_path: 'src/auth.ts',
+        mode: 'complexity_reducer' as Mode,
+        gradient_before: 0.9,
+        gradient_after: 0.7,
+        gradient_delta: undefined as any,
+        changes_made: ['extract function'],
+        tokens_used: 800,
+        cost_usd: 0.03,
+        duration_ms: 25000,
+        success: true,
+      };
+
+      await recordTrace(trace);
+
+      const traces = await readTraces();
+      expect(traces[0].gradient_delta).toBeCloseTo(0.2);
+    });
+
+    it('should append multiple traces', async () => {
+      const trace1: TraceEvent = createTraceEvent({
+        agent_id: 'agent-1',
+        file_path: 'src/test1.ts',
+        mode: 'debt_payer',
+        gradient_before: 0.5,
+        gradient_after: 0.4,
+        changes_made: ['fix lint'],
+        tokens_used: 500,
+        cost_usd: 0.02,
+        duration_ms: 15000,
+        success: true,
+      });
+
+      const trace2: TraceEvent = createTraceEvent({
+        agent_id: 'agent-2',
+        file_path: 'src/test2.ts',
+        mode: 'stabilizer',
+        gradient_before: 0.6,
+        gradient_after: 0.5,
+        changes_made: ['add tests'],
+        tokens_used: 600,
+        cost_usd: 0.025,
+        duration_ms: 20000,
+        success: true,
+      });
+
+      await recordTrace(trace1);
+      await recordTrace(trace2);
+
+      const content = fs.readFileSync(TEST_TRACES_FILE, 'utf-8');
+      const lines = content.trim().split('\n');
+      expect(lines).toHaveLength(2);
+    });
+  });
+
+  describe('readTraces', () => {
+    it('should return empty array if no traces file', async () => {
+      const traces = await readTraces();
+      expect(traces).toEqual([]);
+    });
+
+    it('should read all traces', async () => {
+      // Create test traces
+      const trace1 = createTraceEvent({
+        agent_id: 'agent-1',
+        file_path: 'src/test1.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.8,
+        gradient_after: 0.6,
+        changes_made: ['fix'],
+        tokens_used: 1000,
+        cost_usd: 0.05,
+        duration_ms: 30000,
+        success: true,
+      });
+
+      const trace2 = createTraceEvent({
+        agent_id: 'agent-2',
+        file_path: 'src/test2.ts',
+        mode: 'debt_payer',
+        gradient_before: 0.5,
+        gradient_after: 0.4,
+        changes_made: ['lint'],
+        tokens_used: 500,
+        cost_usd: 0.02,
+        duration_ms: 15000,
+        success: true,
+      });
+
+      await recordTrace(trace1);
+      await recordTrace(trace2);
+
+      const traces = await readTraces();
+      expect(traces).toHaveLength(2);
+    });
+
+    it('should filter by file', async () => {
+      const trace1 = createTraceEvent({
+        agent_id: 'agent-1',
+        file_path: 'src/auth.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.8,
+        gradient_after: 0.6,
+        changes_made: ['fix'],
+        tokens_used: 1000,
+        cost_usd: 0.05,
+        duration_ms: 30000,
+        success: true,
+      });
+
+      const trace2 = createTraceEvent({
+        agent_id: 'agent-2',
+        file_path: 'src/utils.ts',
+        mode: 'debt_payer',
+        gradient_before: 0.5,
+        gradient_after: 0.4,
+        changes_made: ['lint'],
+        tokens_used: 500,
+        cost_usd: 0.02,
+        duration_ms: 15000,
+        success: true,
+      });
+
+      await recordTrace(trace1);
+      await recordTrace(trace2);
+
+      const traces = await readTraces({ file: 'src/auth.ts' });
+      expect(traces).toHaveLength(1);
+      expect(traces[0].file_path).toBe('src/auth.ts');
+    });
+
+    it('should filter by mode', async () => {
+      const trace1 = createTraceEvent({
+        agent_id: 'agent-1',
+        file_path: 'src/test1.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.8,
+        gradient_after: 0.6,
+        changes_made: ['fix'],
+        tokens_used: 1000,
+        cost_usd: 0.05,
+        duration_ms: 30000,
+        success: true,
+      });
+
+      const trace2 = createTraceEvent({
+        agent_id: 'agent-2',
+        file_path: 'src/test2.ts',
+        mode: 'debt_payer',
+        gradient_before: 0.5,
+        gradient_after: 0.4,
+        changes_made: ['lint'],
+        tokens_used: 500,
+        cost_usd: 0.02,
+        duration_ms: 15000,
+        success: true,
+      });
+
+      await recordTrace(trace1);
+      await recordTrace(trace2);
+
+      const traces = await readTraces({ mode: 'debt_payer' });
+      expect(traces).toHaveLength(1);
+      expect(traces[0].mode).toBe('debt_payer');
+    });
+
+    it('should filter by date', async () => {
+      const oldDate = new Date('2025-01-01T00:00:00Z');
+      const recentDate = new Date();
+
+      const trace1: TraceEvent = {
+        id: 'old',
+        timestamp: oldDate.toISOString(),
+        agent_id: 'agent-1',
+        file_path: 'src/test.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.8,
+        gradient_after: 0.6,
+        gradient_delta: 0.2,
+        changes_made: [],
+        tokens_used: 1000,
+        cost_usd: 0.05,
+        duration_ms: 30000,
+        success: true,
+      };
+
+      const trace2 = createTraceEvent({
+        agent_id: 'agent-2',
+        file_path: 'src/test.ts',
+        mode: 'debt_payer',
+        gradient_before: 0.5,
+        gradient_after: 0.4,
+        changes_made: [],
+        tokens_used: 500,
+        cost_usd: 0.02,
+        duration_ms: 15000,
+        success: true,
+      });
+
+      await recordTrace(trace1);
+      await recordTrace(trace2);
+
+      const since = new Date('2025-01-15T00:00:00Z');
+      const traces = await readTraces({ since });
+      expect(traces).toHaveLength(1);
+      expect(new Date(traces[0].timestamp).getTime()).toBeGreaterThanOrEqual(since.getTime());
+    });
+
+    it('should limit results', async () => {
+      for (let i = 0; i < 10; i++) {
+        const trace = createTraceEvent({
+          agent_id: `agent-${i}`,
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.7,
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.05,
+          duration_ms: 30000,
+          success: true,
+        });
+        await recordTrace(trace);
+      }
+
+      const traces = await readTraces({ limit: 5 });
+      expect(traces).toHaveLength(5);
+    });
+
+    it('should sort by timestamp (newest first)', async () => {
+      // Create traces with different timestamps
+      for (let i = 0; i < 5; i++) {
+        const trace = createTraceEvent({
+          agent_id: `agent-${i}`,
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.7,
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.05,
+          duration_ms: 30000,
+          success: true,
+        });
+        await recordTrace(trace);
+        // Small delay to ensure different timestamps
+        await new Promise(resolve => setTimeout(resolve, 10));
+      }
+
+      const traces = await readTraces();
+
+      // Verify descending order
+      for (let i = 0; i < traces.length - 1; i++) {
+        const current = new Date(traces[i].timestamp).getTime();
+        const next = new Date(traces[i + 1].timestamp).getTime();
+        expect(current).toBeGreaterThanOrEqual(next);
+      }
+    });
+  });
+
+  describe('getRecentEfficiency', () => {
+    it('should return null if insufficient data', async () => {
+      // Only 2 traces (need at least 3)
+      for (let i = 0; i < 2; i++) {
+        const trace = createTraceEvent({
+          agent_id: 'agent-1',
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.6,
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.05,
+          duration_ms: 30000,
+          success: true,
+        });
+        await recordTrace(trace);
+      }
+
+      const efficiency = await getRecentEfficiency('src/test.ts', 5);
+      expect(efficiency).toBeNull();
+    });
+
+    it('should calculate efficiency from recent traces', async () => {
+      // Create traces with known efficiency
+      for (let i = 0; i < 5; i++) {
+        const trace = createTraceEvent({
+          agent_id: 'agent-1',
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.6, // delta = 0.2
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.1, // delta/cost = 2.0
+          duration_ms: 30000,
+          success: true,
+        });
+        await recordTrace(trace);
+      }
+
+      const efficiency = await getRecentEfficiency('src/test.ts', 5);
+      expect(efficiency).toBeCloseTo(2.0); // total delta 1.0 / total cost 0.5 = 2.0
+    });
+
+    it('should only consider last N traces', async () => {
+      // Create 10 traces, but only last 3 should be considered
+      for (let i = 0; i < 10; i++) {
+        const trace = createTraceEvent({
+          agent_id: 'agent-1',
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.6,
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.1,
+          duration_ms: 30000,
+          success: true,
+        });
+        await recordTrace(trace);
+      }
+
+      const efficiency = await getRecentEfficiency('src/test.ts', 3);
+      expect(efficiency).not.toBeNull();
+    });
+  });
+
+  describe('calculateEfficiency', () => {
+    it('should return 0 for empty traces', () => {
+      const efficiency = calculateEfficiency([]);
+      expect(efficiency).toBe(0);
+    });
+
+    it('should calculate efficiency correctly', () => {
+      const traces: TraceEvent[] = [
+        createTraceEvent({
+          agent_id: 'agent-1',
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.6, // delta = 0.2
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.1,
+          duration_ms: 30000,
+          success: true,
+        }),
+        createTraceEvent({
+          agent_id: 'agent-2',
+          file_path: 'src/test.ts',
+          mode: 'debt_payer',
+          gradient_before: 0.6,
+          gradient_after: 0.5, // delta = 0.1
+          changes_made: [],
+          tokens_used: 500,
+          cost_usd: 0.05,
+          duration_ms: 15000,
+          success: true,
+        }),
+      ];
+
+      // Total delta = 0.3, total cost = 0.15
+      // Efficiency = 0.3 / 0.15 = 2.0
+      const efficiency = calculateEfficiency(traces);
+      expect(efficiency).toBeCloseTo(2.0);
+    });
+
+    it('should handle zero cost (return Infinity)', () => {
+      const traces: TraceEvent[] = [
+        createTraceEvent({
+          agent_id: 'agent-1',
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.6,
+          changes_made: [],
+          tokens_used: 0,
+          cost_usd: 0,
+          duration_ms: 30000,
+          success: true,
+        }),
+      ];
+
+      const efficiency = calculateEfficiency(traces);
+      expect(efficiency).toBe(Infinity);
+    });
+  });
+
+  describe('getTraceStats', () => {
+    it('should return zero stats for empty traces', () => {
+      const stats = getTraceStats([]);
+      expect(stats.totalCost).toBe(0);
+      expect(stats.avgDelta).toBe(0);
+      expect(stats.successRate).toBe(0);
+      expect(stats.totalTraces).toBe(0);
+    });
+
+    it('should calculate statistics correctly', () => {
+      const traces: TraceEvent[] = [
+        createTraceEvent({
+          agent_id: 'agent-1',
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.6,
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.1,
+          duration_ms: 30000,
+          success: true,
+        }),
+        createTraceEvent({
+          agent_id: 'agent-2',
+          file_path: 'src/test.ts',
+          mode: 'debt_payer',
+          gradient_before: 0.6,
+          gradient_after: 0.5,
+          changes_made: [],
+          tokens_used: 500,
+          cost_usd: 0.05,
+          duration_ms: 15000,
+          success: true,
+        }),
+        createTraceEvent({
+          agent_id: 'agent-3',
+          file_path: 'src/test.ts',
+          mode: 'complexity_reducer',
+          gradient_before: 0.5,
+          gradient_after: 0.5,
+          changes_made: [],
+          tokens_used: 800,
+          cost_usd: 0.08,
+          duration_ms: 25000,
+          success: false,
+        }),
+      ];
+
+      const stats = getTraceStats(traces);
+      expect(stats.totalCost).toBeCloseTo(0.23);
+      expect(stats.avgDelta).toBeCloseTo(0.1); // (0.2 + 0.1 + 0) / 3
+      expect(stats.successRate).toBeCloseTo(0.667); // 2/3
+      expect(stats.totalTraces).toBe(3);
+    });
+  });
+
+  describe('generateTraceId', () => {
+    it('should generate unique IDs', () => {
+      const id1 = generateTraceId();
+      const id2 = generateTraceId();
+
+      expect(id1).toBeTruthy();
+      expect(id2).toBeTruthy();
+      expect(id1).not.toBe(id2);
+    });
+
+    it('should generate valid UUIDs', () => {
+      const id = generateTraceId();
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+      expect(id).toMatch(uuidRegex);
+    });
+  });
+
+  describe('calculateCost', () => {
+    it('should calculate cost for Sonnet 4', () => {
+      const cost = calculateCost(1_000_000, 1_000_000, 'claude-sonnet-4');
+      // Input: 1M tokens * $3/M = $3
+      // Output: 1M tokens * $15/M = $15
+      // Total: $18
+      expect(cost).toBeCloseTo(18.0);
+    });
+
+    it('should calculate cost for Haiku 4', () => {
+      const cost = calculateCost(1_000_000, 1_000_000, 'claude-haiku-4');
+      // Input: 1M tokens * $0.25/M = $0.25
+      // Output: 1M tokens * $1.25/M = $1.25
+      // Total: $1.50
+      expect(cost).toBeCloseTo(1.50);
+    });
+
+    it('should default to Sonnet 4 for unknown models', () => {
+      const cost = calculateCost(1_000_000, 1_000_000, 'unknown-model');
+      expect(cost).toBeCloseTo(18.0);
+    });
+
+    it('should calculate fractional costs', () => {
+      const cost = calculateCost(500_000, 100_000, 'claude-sonnet-4');
+      // Input: 0.5M tokens * $3/M = $1.50
+      // Output: 0.1M tokens * $15/M = $1.50
+      // Total: $3.00
+      expect(cost).toBeCloseTo(3.0);
+    });
+  });
+
+  describe('createTraceEvent', () => {
+    it('should create trace with generated ID and timestamp', () => {
+      const trace = createTraceEvent({
+        agent_id: 'agent-1',
+        file_path: 'src/test.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.8,
+        gradient_after: 0.6,
+        changes_made: [],
+        tokens_used: 1000,
+        cost_usd: 0.05,
+        duration_ms: 30000,
+        success: true,
+      });
+
+      expect(trace.id).toBeTruthy();
+      expect(trace.timestamp).toBeTruthy();
+      expect(trace.gradient_delta).toBeCloseTo(0.2);
+    });
+
+    it('should calculate gradient_delta automatically', () => {
+      const trace = createTraceEvent({
+        agent_id: 'agent-1',
+        file_path: 'src/test.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.9,
+        gradient_after: 0.5,
+        changes_made: [],
+        tokens_used: 1000,
+        cost_usd: 0.05,
+        duration_ms: 30000,
+        success: true,
+      });
+
+      expect(trace.gradient_delta).toBeCloseTo(0.4);
+    });
+  });
+
+  describe('concurrent writes', () => {
+    it('should handle concurrent trace recording', async () => {
+      // Simulate multiple agents writing concurrently
+      const promises = [];
+      for (let i = 0; i < 10; i++) {
+        const trace = createTraceEvent({
+          agent_id: `agent-${i}`,
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.6,
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.05,
+          duration_ms: 30000,
+          success: true,
+        });
+        promises.push(recordTrace(trace));
+      }
+
+      await Promise.all(promises);
+
+      const traces = await readTraces();
+      expect(traces).toHaveLength(10);
+    });
+  });
+
+  describe('JSONL format', () => {
+    it('should store each trace on a separate line', async () => {
+      for (let i = 0; i < 3; i++) {
+        const trace = createTraceEvent({
+          agent_id: `agent-${i}`,
+          file_path: 'src/test.ts',
+          mode: 'error_reducer',
+          gradient_before: 0.8,
+          gradient_after: 0.6,
+          changes_made: [],
+          tokens_used: 1000,
+          cost_usd: 0.05,
+          duration_ms: 30000,
+          success: true,
+        });
+        await recordTrace(trace);
+      }
+
+      const content = fs.readFileSync(TEST_TRACES_FILE, 'utf-8');
+      const lines = content.trim().split('\n');
+      expect(lines).toHaveLength(3);
+
+      // Each line should be valid JSON
+      lines.forEach(line => {
+        expect(() => JSON.parse(line)).not.toThrow();
+      });
+    });
+  });
+});