claude-mycelium 2.0.0

package/tests/coordination/gradient-cache.test.ts

@@ -0,0 +1,270 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  getCachedGradient,
+  setCachedGradient,
+  invalidateGradient,
+  invalidateGradientCache,
+  getGradientCacheStats,
+  getOrComputeGradient,
+  getOrComputeGradientBatch,
+} from '../../src/coordination/gradient-cache';
+import type { GradientScore } from '../../src/core/gradient';
+
+describe('gradient cache', () => {
+  const createMockGradient = (file: string, score: number): GradientScore => ({
+    file,
+    score,
+    signals: {
+      complexity: 0.5,
+      churn: 0.3,
+      error_rate: 0.2,
+      debt: 0.4,
+      centrality: 0.6,
+    },
+    breakdown: {
+      baseScore: 0.4,
+      impactMultiplier: 0.75,
+      efficiencyPenalty: 0,
+    },
+    dominantSignal: {
+      name: 'complexity',
+      value: 0.5,
+    },
+  });
+
+  beforeEach(() => {
+    // Clear cache before each test
+    invalidateGradientCache();
+  });
+
+  describe('basic caching', () => {
+    it('returns null for uncached file', () => {
+      const result = getCachedGradient('test.ts');
+      expect(result).toBeNull();
+    });
+
+    it('caches and retrieves gradient', () => {
+      const gradient = createMockGradient('test.ts', 0.5);
+      setCachedGradient(gradient);
+
+      const cached = getCachedGradient('test.ts');
+      expect(cached).toEqual(gradient);
+    });
+
+    it('handles multiple files independently', () => {
+      const gradient1 = createMockGradient('file1.ts', 0.5);
+      const gradient2 = createMockGradient('file2.ts', 0.7);
+
+      setCachedGradient(gradient1);
+      setCachedGradient(gradient2);
+
+      expect(getCachedGradient('file1.ts')?.score).toBe(0.5);
+      expect(getCachedGradient('file2.ts')?.score).toBe(0.7);
+    });
+
+    it('overwrites existing cache entry', () => {
+      const gradient1 = createMockGradient('test.ts', 0.5);
+      const gradient2 = createMockGradient('test.ts', 0.8);
+
+      setCachedGradient(gradient1);
+      setCachedGradient(gradient2);
+
+      const cached = getCachedGradient('test.ts');
+      expect(cached?.score).toBe(0.8);
+    });
+  });
+
+  describe('cache expiration', () => {
+    it('expires cache after TTL', async () => {
+      const gradient = createMockGradient('test.ts', 0.5);
+      setCachedGradient(gradient);
+
+      // Mock time passing (5 minutes + 1 second)
+      vi.useFakeTimers();
+      vi.advanceTimersByTime(5 * 60 * 1000 + 1000);
+
+      const cached = getCachedGradient('test.ts');
+      expect(cached).toBeNull();
+
+      vi.useRealTimers();
+    });
+
+    it('does not expire before TTL', async () => {
+      const gradient = createMockGradient('test.ts', 0.5);
+      setCachedGradient(gradient);
+
+      // Mock time passing (4 minutes)
+      vi.useFakeTimers();
+      vi.advanceTimersByTime(4 * 60 * 1000);
+
+      const cached = getCachedGradient('test.ts');
+      expect(cached).not.toBeNull();
+      expect(cached?.score).toBe(0.5);
+
+      vi.useRealTimers();
+    });
+  });
+
+  describe('cache invalidation', () => {
+    it('invalidates specific file', () => {
+      const gradient1 = createMockGradient('file1.ts', 0.5);
+      const gradient2 = createMockGradient('file2.ts', 0.7);
+
+      setCachedGradient(gradient1);
+      setCachedGradient(gradient2);
+
+      invalidateGradient('file1.ts');
+
+      expect(getCachedGradient('file1.ts')).toBeNull();
+      expect(getCachedGradient('file2.ts')).not.toBeNull();
+    });
+
+    it('invalidates entire cache', () => {
+      const gradient1 = createMockGradient('file1.ts', 0.5);
+      const gradient2 = createMockGradient('file2.ts', 0.7);
+
+      setCachedGradient(gradient1);
+      setCachedGradient(gradient2);
+
+      invalidateGradientCache();
+
+      expect(getCachedGradient('file1.ts')).toBeNull();
+      expect(getCachedGradient('file2.ts')).toBeNull();
+    });
+
+    it('handles invalidating non-existent file', () => {
+      expect(() => invalidateGradient('nonexistent.ts')).not.toThrow();
+    });
+  });
+
+  describe('cache statistics', () => {
+    it('returns empty stats for empty cache', () => {
+      const stats = getGradientCacheStats();
+      expect(stats.size).toBe(0);
+      expect(stats.entries).toHaveLength(0);
+    });
+
+    it('returns stats for cached entries', () => {
+      const gradient1 = createMockGradient('file1.ts', 0.5);
+      const gradient2 = createMockGradient('file2.ts', 0.7);
+
+      setCachedGradient(gradient1);
+      setCachedGradient(gradient2);
+
+      const stats = getGradientCacheStats();
+      expect(stats.size).toBe(2);
+      expect(stats.entries).toHaveLength(2);
+    });
+
+    it('includes age in seconds', () => {
+      const gradient = createMockGradient('test.ts', 0.5);
+      setCachedGradient(gradient);
+
+      vi.useFakeTimers();
+      vi.advanceTimersByTime(30 * 1000); // 30 seconds
+
+      const stats = getGradientCacheStats();
+      expect(stats.entries[0].age).toBe(30);
+
+      vi.useRealTimers();
+    });
+
+    it('sorts entries by age (oldest first)', () => {
+      const gradient1 = createMockGradient('file1.ts', 0.5);
+      setCachedGradient(gradient1);
+
+      vi.useFakeTimers();
+      vi.advanceTimersByTime(10 * 1000);
+
+      const gradient2 = createMockGradient('file2.ts', 0.7);
+      setCachedGradient(gradient2);
+
+      const stats = getGradientCacheStats();
+      expect(stats.entries[0].age).toBeGreaterThan(stats.entries[1].age);
+
+      vi.useRealTimers();
+    });
+  });
+
+  describe('getOrComputeGradient', () => {
+    it('returns cached gradient if available', async () => {
+      const gradient = createMockGradient('test.ts', 0.5);
+      setCachedGradient(gradient);
+
+      const computeFn = vi.fn();
+      const result = await getOrComputeGradient('test.ts', computeFn);
+
+      expect(result).toEqual(gradient);
+      expect(computeFn).not.toHaveBeenCalled();
+    });
+
+    it('computes and caches if not cached', async () => {
+      const gradient = createMockGradient('test.ts', 0.5);
+      const computeFn = vi.fn().mockResolvedValue(gradient);
+
+      const result = await getOrComputeGradient('test.ts', computeFn);
+
+      expect(result).toEqual(gradient);
+      expect(computeFn).toHaveBeenCalledOnce();
+      expect(getCachedGradient('test.ts')).toEqual(gradient);
+    });
+  });
+
+  describe('getOrComputeGradientBatch', () => {
+    it('returns all cached if all available', async () => {
+      const gradient1 = createMockGradient('file1.ts', 0.5);
+      const gradient2 = createMockGradient('file2.ts', 0.7);
+
+      setCachedGradient(gradient1);
+      setCachedGradient(gradient2);
+
+      const computeBatchFn = vi.fn();
+      const results = await getOrComputeGradientBatch(
+        ['file1.ts', 'file2.ts'],
+        computeBatchFn
+      );
+
+      expect(results.size).toBe(2);
+      expect(computeBatchFn).not.toHaveBeenCalled();
+    });
+
+    it('computes only uncached files', async () => {
+      const gradient1 = createMockGradient('file1.ts', 0.5);
+      setCachedGradient(gradient1);
+
+      const gradient2 = createMockGradient('file2.ts', 0.7);
+      const computeBatchFn = vi
+        .fn()
+        .mockResolvedValue(new Map([['file2.ts', gradient2]]));
+
+      const results = await getOrComputeGradientBatch(
+        ['file1.ts', 'file2.ts'],
+        computeBatchFn
+      );
+
+      expect(results.size).toBe(2);
+      expect(computeBatchFn).toHaveBeenCalledWith(['file2.ts']);
+      expect(results.get('file1.ts')?.score).toBe(0.5);
+      expect(results.get('file2.ts')?.score).toBe(0.7);
+    });
+
+    it('caches newly computed gradients', async () => {
+      const gradient = createMockGradient('test.ts', 0.5);
+      const computeBatchFn = vi
+        .fn()
+        .mockResolvedValue(new Map([['test.ts', gradient]]));
+
+      await getOrComputeGradientBatch(['test.ts'], computeBatchFn);
+
+      expect(getCachedGradient('test.ts')).toEqual(gradient);
+    });
+
+    it('handles empty file list', async () => {
+      const computeBatchFn = vi.fn();
+      const results = await getOrComputeGradientBatch([], computeBatchFn);
+
+      expect(results.size).toBe(0);
+      expect(computeBatchFn).not.toHaveBeenCalled();
+    });
+  });
+});

package/tests/core/agent-executor.test.ts

@@ -0,0 +1,217 @@
+/**
+ * Agent Executor Tests
+ * Tests the main agent execution flow with mocked dependencies
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { executeAgent } from '../../src/core/agent-executor.js';
+import type { Mode } from '../../src/types/index.js';
+import { writeFile, readFile, unlink } from 'fs/promises';
+import { randomUUID } from 'crypto';
+
+// Test fixture file
+const TEST_FILE = `test-${randomUUID()}.ts`;
+const TEST_CONTENT = `function add(a: number, b: number): number {
+  return a + b;
+}`;
+
+describe('Agent Executor', () => {
+  beforeEach(async () => {
+    // Create test file
+    await writeFile(TEST_FILE, TEST_CONTENT, 'utf-8');
+
+    // Mock environment
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+  });
+
+  afterEach(async () => {
+    // Clean up test file
+    try {
+      await unlink(TEST_FILE);
+    } catch {
+      // File may not exist
+    }
+  });
+
+  describe('Full execution flow', () => {
+    it.skip('should execute agent and return result', async () => {
+      // Mock LLM response
+      vi.mock('../../src/llm/anthropic-client.js', async (importOriginal) => {
+        const actual = await importOriginal();
+        return {
+          ...actual,
+          callLLM: vi.fn().mockResolvedValue({
+            content: `Here's the improved code:
+
+\`\`\`typescript
+function add(a: number, b: number): number {
+  // Validate inputs
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('Arguments must be numbers');
+  }
+  return a + b;
+}
+\`\`\``,
+            usage: {
+              inputTokens: 100,
+              outputTokens: 150,
+            },
+            model: 'claude-sonnet-4-20250514',
+          }),
+        };
+      });
+
+      // Mock CI provider
+      vi.mock('../../src/utils/ci-provider.js', () => ({
+        ciProvider: {
+          run: vi.fn().mockResolvedValue({
+            passed: true,
+            output: 'All tests passed',
+          }),
+        },
+      }));
+
+      const result = await executeAgent(TEST_FILE, 'error_reducer', {
+        dryRun: false,
+        maxRetries: 1,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.changes).toContain(TEST_FILE);
+      expect(result.trace).toBeDefined();
+      expect(result.trace.mode).toBe('error_reducer');
+      expect(result.cost).toBeGreaterThan(0);
+    }, 30000); // 30 second timeout for LLM calls
+  });
+
+  describe('Dry run mode', () => {
+    it('should not modify files in dry run', async () => {
+      const contentBefore = await readFile(TEST_FILE, 'utf-8');
+
+      await executeAgent(TEST_FILE, 'complexity_reducer', {
+        dryRun: true,
+      });
+
+      const contentAfter = await readFile(TEST_FILE, 'utf-8');
+      expect(contentAfter).toBe(contentBefore);
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should retry on LLM failure', async () => {
+      vi.mock('../../src/llm/anthropic-client.js', () => ({
+        callLLM: vi
+          .fn()
+          .mockRejectedValueOnce(new Error('API error'))
+          .mockResolvedValueOnce({
+            content: '```typescript\nfunction test() {}\n```',
+            tokensIn: 50,
+            tokensOut: 75,
+            model: 'claude-sonnet-4-20250514',
+            stopReason: 'end_turn',
+          }),
+      }));
+
+      const result = await executeAgent(TEST_FILE, 'debt_payer', {
+        maxRetries: 2,
+        dryRun: true,
+      });
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should rollback on CI failure', async () => {
+      const contentBefore = await readFile(TEST_FILE, 'utf-8');
+
+      vi.mock('../../src/llm/anthropic-client.js', () => ({
+        callLLM: vi.fn().mockResolvedValue({
+          content: '```typescript\nfunction broken() { syntax error }\n```',
+          usage: {
+            inputTokens: 50,
+            outputTokens: 75,
+          },
+          model: 'claude-sonnet-4-20250514',
+        }),
+      }));
+
+      vi.mock('../../src/utils/ci-provider.js', () => ({
+        ciProvider: {
+          run: vi.fn().mockResolvedValue({
+            passed: false,
+            output: 'Syntax error',
+          }),
+        },
+      }));
+
+      await expect(
+        executeAgent(TEST_FILE, 'error_reducer', {
+          dryRun: false,
+        })
+      ).rejects.toThrow();
+
+      // File should be rolled back
+      const contentAfter = await readFile(TEST_FILE, 'utf-8');
+      expect(contentAfter).toBe(contentBefore);
+    });
+
+    it.skip('should handle invalid LLM response', async () => {
+      vi.mock('../../src/llm/anthropic-client.js', () => ({
+        callLLM: vi.fn().mockResolvedValue({
+          content: 'No code block here!',
+          usage: {
+            inputTokens: 50,
+            outputTokens: 20,
+          },
+          model: 'claude-sonnet-4-20250514',
+          stopReason: 'end_turn',
+        }),
+      }));
+
+      await expect(
+        executeAgent(TEST_FILE, 'error_reducer', {
+          dryRun: true,
+        })
+      ).rejects.toThrow('Failed to parse valid code changes');
+    });
+  });
+
+  describe('Cost calculation', () => {
+    it.skip('should calculate cost correctly', async () => {
+      vi.mock('../../src/llm/anthropic-client.js', () => ({
+        callLLM: vi.fn().mockResolvedValue({
+          content: '```typescript\nfunction test() {}\n```',
+          usage: {
+            inputTokens: 1000,
+            outputTokens: 500,
+          },
+          model: 'claude-sonnet-4-20250514',
+          stopReason: 'end_turn',
+        }),
+      }));
+
+      const result = await executeAgent(TEST_FILE, 'error_reducer', {
+        dryRun: true,
+      });
+
+      // Sonnet pricing: $3/MTok input, $15/MTok output
+      // (1000 * 3 + 500 * 15) / 1_000_000 = $0.0105
+      expect(result.cost).toBeCloseTo(0.0105, 4);
+    });
+  });
+
+  describe('Trace recording', () => {
+    it('should record trace with correct metrics', async () => {
+      const result = await executeAgent(TEST_FILE, 'error_reducer', {
+        dryRun: true,
+      });
+
+      expect(result.trace.file_path).toBe(TEST_FILE);
+      expect(result.trace.mode).toBe('error_reducer');
+      expect(result.trace.gradient_before).toBeGreaterThanOrEqual(0);
+      expect(result.trace.gradient_after).toBeGreaterThanOrEqual(0);
+      expect(result.trace.cost.tokens_in).toBeGreaterThan(0);
+      expect(result.trace.cost.tokens_out).toBeGreaterThan(0);
+      expect(result.trace.efficiency).toBeDefined();
+    });
+  });
+});