claude-mycelium 2.0.0 → 2.2.0

package/tests/quarantine/explorer.test.ts

@@ -0,0 +1,381 @@
+/**
+ * Tests for Explorer Mode Spawning
+ * Validates probability calculations and target selection
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import {
+  shouldSpawnExplorer,
+  selectExplorerTarget,
+  calculateExplorerProbability,
+  shouldSpawnExplorerForFile,
+  getExplorerConfig,
+  formatExplorerInstructions,
+} from '../../src/quarantine/explorer.js';
+import { addToQuarantine } from '../../src/quarantine/manager.js';
+import type { Gradient } from '../../src/types/index.js';
+import type { TraceEvent } from '../../src/trace/trace-event.js';
+
+describe('Explorer Mode', () => {
+  let TEST_DIR: string;
+
+  beforeEach(() => {
+    // Create unique test directory for each test
+    TEST_DIR = `.agent-meta-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+
+    if (!fs.existsSync(TEST_DIR)) {
+      fs.mkdirSync(TEST_DIR, { recursive: true });
+    }
+
+    process.env.TEST_META_DIR = TEST_DIR;
+  });
+
+  afterEach(() => {
+    // Cleanup test files
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+    // Clean up environment
+    delete process.env.TEST_META_DIR;
+  });
+
+  const createMockTrace = (efficiency: number): TraceEvent => ({
+    id: `trace-${Date.now()}-${Math.random()}`,
+    timestamp: new Date().toISOString(),
+    agent_id: 'test-agent',
+    file_path: 'test.ts',
+    mode: 'error_reducer',
+    gradient_before: 0.5,
+    gradient_after: 0.48,
+    gradient_delta: 0.02,
+    changes_made: [],
+    tokens_used: 1000,
+    cost_usd: 0.01,
+    duration_ms: 1000,
+    success: true,
+    efficiency,
+    ci_passed: true,
+    changes: {
+      additions: 1,
+      deletions: 1,
+      files_touched: ['test.ts'],
+    },
+    cost: {
+      tokens_in: 500,
+      tokens_out: 500,
+      model: 'claude-sonnet-4',
+      estimated_usd: 0.01,
+    },
+  });
+
+  describe('calculateExplorerProbability', () => {
+    it('should calculate 10% probability for centrality 0.0', () => {
+      const prob = calculateExplorerProbability(0.0);
+      expect(prob).toBeCloseTo(0.1, 3);
+    });
+
+    it('should calculate 15% probability for centrality 0.5', () => {
+      const prob = calculateExplorerProbability(0.5);
+      expect(prob).toBeCloseTo(0.15, 3);
+    });
+
+    it('should calculate 20% probability for centrality 1.0', () => {
+      const prob = calculateExplorerProbability(1.0);
+      expect(prob).toBeCloseTo(0.2, 3);
+    });
+
+    it('should follow formula: 0.1 × (1 + centrality)', () => {
+      const centrality = 0.75;
+      const expected = 0.1 * (1 + centrality);
+      const actual = calculateExplorerProbability(centrality);
+      expect(actual).toBeCloseTo(expected, 5);
+    });
+  });
+
+  describe('shouldSpawnExplorer', () => {
+    it('should return false with insufficient data (<10 traces)', async () => {
+      const getRecentTraces = async (limit: number) => {
+        return Array(5)
+          .fill(0)
+          .map(() => createMockTrace(0.1));
+      };
+
+      const result = await shouldSpawnExplorer(getRecentTraces);
+      expect(result).toBe(false);
+    });
+
+    it('should have low probability with high efficiency (>=0.3)', async () => {
+      const getRecentTraces = async (limit: number) => {
+        return Array(20)
+          .fill(0)
+          .map(() => createMockTrace(0.35)); // High efficiency
+      };
+
+      // Run multiple times to check probability
+      let spawnCount = 0;
+      const iterations = 100;
+
+      for (let i = 0; i < iterations; i++) {
+        if (await shouldSpawnExplorer(getRecentTraces)) {
+          spawnCount++;
+        }
+      }
+
+      const probability = spawnCount / iterations;
+      // Should be around 5% (base probability)
+      expect(probability).toBeLessThan(0.15); // Allow some variance
+    });
+
+    it('should have medium probability with medium efficiency (0.15)', async () => {
+      const getRecentTraces = async (limit: number) => {
+        return Array(20)
+          .fill(0)
+          .map(() => createMockTrace(0.15)); // Medium efficiency
+      };
+
+      // Run multiple times to check probability
+      let spawnCount = 0;
+      const iterations = 200;
+
+      for (let i = 0; i < iterations; i++) {
+        if (await shouldSpawnExplorer(getRecentTraces)) {
+          spawnCount++;
+        }
+      }
+
+      const probability = spawnCount / iterations;
+      // Should be around 15% (halfway to max)
+      expect(probability).toBeGreaterThan(0.08); // Lower bound
+      expect(probability).toBeLessThan(0.22); // Upper bound
+    });
+
+    it('should have high probability with low efficiency (0.0)', async () => {
+      const getRecentTraces = async (limit: number) => {
+        return Array(20)
+          .fill(0)
+          .map(() => createMockTrace(0.0)); // Zero efficiency
+      };
+
+      // Run multiple times to check probability
+      let spawnCount = 0;
+      const iterations = 200;
+
+      for (let i = 0; i < iterations; i++) {
+        if (await shouldSpawnExplorer(getRecentTraces)) {
+          spawnCount++;
+        }
+      }
+
+      const probability = spawnCount / iterations;
+      // Should be around 25% (max probability)
+      expect(probability).toBeGreaterThan(0.18); // Lower bound
+      expect(probability).toBeLessThan(0.32); // Upper bound
+    });
+  });
+
+  describe('selectExplorerTarget', () => {
+    const mockIsFileLocked = async (file: string) => false;
+
+    it('should prioritize quarantined files with attempts remaining', async () => {
+      // Add quarantined file
+      await addToQuarantine({
+        file: 'quarantined.ts',
+        quarantined_at: new Date().toISOString(),
+        reason: 'Test',
+        attempts_before_quarantine: 10,
+        explorer_attempts: 0,
+        max_explorer_attempts: 3,
+      });
+
+      const gradients: Gradient[] = [
+        {
+          file: 'high-gradient.ts',
+          score: 0.9,
+          baseScore: 0.9,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'complexity',
+        },
+        {
+          file: 'quarantined.ts',
+          score: 0.5,
+          baseScore: 0.5,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'error_rate',
+        },
+      ];
+
+      const target = await selectExplorerTarget(gradients, mockIsFileLocked);
+
+      // Should pick quarantined file even though high-gradient.ts has higher score
+      expect(target).toBe('quarantined.ts');
+    });
+
+    it('should skip quarantined files with exhausted attempts', async () => {
+      // Add quarantined file with exhausted attempts
+      await addToQuarantine({
+        file: 'exhausted.ts',
+        quarantined_at: new Date().toISOString(),
+        reason: 'Test',
+        attempts_before_quarantine: 10,
+        explorer_attempts: 3, // Exhausted
+        max_explorer_attempts: 3,
+      });
+
+      const gradients: Gradient[] = [
+        {
+          file: 'high-gradient.ts',
+          score: 0.9,
+          baseScore: 0.9,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'complexity',
+        },
+        {
+          file: 'exhausted.ts',
+          score: 0.8,
+          baseScore: 0.8,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'error_rate',
+        },
+      ];
+
+      const target = await selectExplorerTarget(gradients, mockIsFileLocked);
+
+      // Should pick high-gradient file since quarantined one is exhausted
+      expect(target).toBe('high-gradient.ts');
+    });
+
+    it('should pick highest gradient among non-quarantined files', async () => {
+      const gradients: Gradient[] = [
+        {
+          file: 'low.ts',
+          score: 0.3,
+          baseScore: 0.3,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'churn',
+        },
+        {
+          file: 'high.ts',
+          score: 0.9,
+          baseScore: 0.9,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'complexity',
+        },
+        {
+          file: 'medium.ts',
+          score: 0.6,
+          baseScore: 0.6,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'debt',
+        },
+      ];
+
+      const target = await selectExplorerTarget(gradients, mockIsFileLocked);
+      expect(target).toBe('high.ts');
+    });
+
+    it('should skip locked files', async () => {
+      const mockIsFileLockedSelective = async (file: string) => file === 'locked.ts';
+
+      const gradients: Gradient[] = [
+        {
+          file: 'locked.ts',
+          score: 0.9,
+          baseScore: 0.9,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'complexity',
+        },
+        {
+          file: 'unlocked.ts',
+          score: 0.7,
+          baseScore: 0.7,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'error_rate',
+        },
+      ];
+
+      const target = await selectExplorerTarget(gradients, mockIsFileLockedSelective);
+      expect(target).toBe('unlocked.ts');
+    });
+
+    it('should return null if no valid targets', async () => {
+      const mockAllLocked = async (file: string) => true;
+
+      const gradients: Gradient[] = [
+        {
+          file: 'locked1.ts',
+          score: 0.9,
+          baseScore: 0.9,
+          impactMultiplier: 1.0,
+          efficiencyPenalty: 1.0,
+          dominantSignal: 'complexity',
+        },
+      ];
+
+      const target = await selectExplorerTarget(gradients, mockAllLocked);
+      expect(target).toBeNull();
+    });
+  });
+
+  describe('shouldSpawnExplorerForFile', () => {
+    it('should be probabilistic based on centrality', () => {
+      // Run many times to verify probability distribution
+      const centrality = 0.5; // Should give ~15% probability
+      let spawnCount = 0;
+      const iterations = 1000;
+
+      for (let i = 0; i < iterations; i++) {
+        if (shouldSpawnExplorerForFile(centrality)) {
+          spawnCount++;
+        }
+      }
+
+      const probability = spawnCount / iterations;
+      expect(probability).toBeGreaterThan(0.10); // Lower bound
+      expect(probability).toBeLessThan(0.20); // Upper bound
+    });
+  });
+
+  describe('getExplorerConfig', () => {
+    it('should return explorer configuration', () => {
+      const config = getExplorerConfig();
+
+      expect(config.temperature).toBeGreaterThan(0);
+      expect(config.systemPromptAddition).toContain('EXPLORER');
+      expect(config.systemPromptAddition).toContain('creative');
+    });
+
+    it('should have higher temperature than normal modes', () => {
+      const config = getExplorerConfig();
+      // Normal modes typically use 0.3-0.5, explorer should be higher
+      expect(config.temperature).toBeGreaterThanOrEqual(0.7);
+    });
+  });
+
+  describe('formatExplorerInstructions', () => {
+    it('should format instructions for quarantined file', () => {
+      const instructions = formatExplorerInstructions('test.ts', true, 2);
+
+      expect(instructions).toContain('QUARANTINED');
+      expect(instructions).toContain('test.ts');
+      expect(instructions).toContain('multiple');
+    });
+
+    it('should format instructions for non-quarantined file', () => {
+      const instructions = formatExplorerInstructions('test.ts', false, 0);
+
+      expect(instructions).toContain('Creative Exploration');
+      expect(instructions).toContain('test.ts');
+      expect(instructions).not.toContain('QUARANTINED');
+    });
+  });
+});