claude-mycelium 2.0.0 → 2.2.0

package/tests/coordination/inhibitors.test.ts

@@ -0,0 +1,459 @@
+/**
+ * Tests for Inhibitor Signal System
+ * Validates emission, decay, and querying
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  emitInhibitor,
+  queryInhibitors,
+  calculateCurrentStrength,
+  readInhibitors,
+  extractFailurePattern,
+  summarizeCIFailure,
+  maybeEmitInhibitor,
+  checkForLoop,
+  gcInhibitors,
+  formatInhibitorForPrompt,
+} from '../../src/coordination/inhibitors.js';
+import type { Inhibitor, Mode } from '../../src/types/index.js';
+import type { TraceEvent } from '../../src/trace/trace-event.js';
+
+describe('Inhibitor System', () => {
+  let TEST_DIR: string;
+  let INHIBITORS_FILE: string;
+
+  beforeEach(() => {
+    // Create unique test directory for each test
+    TEST_DIR = `.agent-meta-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    INHIBITORS_FILE = path.join(TEST_DIR, '_inhibitors.ndjson');
+
+    if (!fs.existsSync(TEST_DIR)) {
+      fs.mkdirSync(TEST_DIR, { recursive: true });
+    }
+
+    // Override file path for testing
+    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;
+  });
+
+  describe('emitInhibitor', () => {
+    it('should emit inhibitor with correct structure', async () => {
+      const inhibitor = await emitInhibitor({
+        trigger: {
+          file: 'src/test.ts',
+          mode: 'complexity_reducer',
+          pattern: 'removing null checks',
+        },
+        signal: 'CI failed: TypeError: Cannot read property x of undefined',
+        origin: {
+          agent_id: 'agent-123',
+          trace_id: 'trace-456',
+          energy_wasted: 0.04,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      });
+
+      expect(inhibitor.id).toBeDefined();
+      expect(inhibitor.timestamp).toBeDefined();
+      expect(inhibitor.trigger.file).toBe('src/test.ts');
+      expect(inhibitor.trigger.mode).toBe('complexity_reducer');
+      expect(inhibitor.trigger.pattern).toBe('removing null checks');
+      expect(inhibitor.strength).toBe(1.0);
+      expect(inhibitor.half_life_days).toBe(30);
+    });
+
+    it('should append to NDJSON file', async () => {
+      await emitInhibitor({
+        trigger: { file: 'test1.ts', mode: 'error_reducer' },
+        signal: 'Test failure 1',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      });
+
+      await emitInhibitor({
+        trigger: { file: 'test2.ts', mode: 'debt_payer' },
+        signal: 'Test failure 2',
+        origin: {
+          agent_id: 'a2',
+          trace_id: 't2',
+          energy_wasted: 0.02,
+          failure_type: 'regression',
+        },
+        strength: 0.8,
+        half_life_days: 30,
+      });
+
+      const all = await readInhibitors();
+      expect(all.length).toBe(2);
+      expect(all[0].trigger.file).toBe('test1.ts');
+      expect(all[1].trigger.file).toBe('test2.ts');
+    });
+  });
+
+  describe('calculateCurrentStrength', () => {
+    it('should calculate correct decay at 0 days', () => {
+      const inhibitor: Inhibitor = {
+        id: '1',
+        timestamp: new Date().toISOString(),
+        trigger: {},
+        signal: 'test',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      };
+
+      const strength = calculateCurrentStrength(inhibitor);
+      expect(strength).toBeCloseTo(1.0, 2);
+    });
+
+    it('should decay to 0.5 at one half-life (30 days)', () => {
+      const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+      const inhibitor: Inhibitor = {
+        id: '1',
+        timestamp: thirtyDaysAgo.toISOString(),
+        trigger: {},
+        signal: 'test',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      };
+
+      const strength = calculateCurrentStrength(inhibitor);
+      expect(strength).toBeCloseTo(0.5, 2);
+    });
+
+    it('should decay to 0.25 at two half-lives (60 days)', () => {
+      const sixtyDaysAgo = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000);
+      const inhibitor: Inhibitor = {
+        id: '1',
+        timestamp: sixtyDaysAgo.toISOString(),
+        trigger: {},
+        signal: 'test',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      };
+
+      const strength = calculateCurrentStrength(inhibitor);
+      expect(strength).toBeCloseTo(0.25, 2);
+    });
+
+    it('should decay to 0.125 at three half-lives (90 days)', () => {
+      const ninetyDaysAgo = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);
+      const inhibitor: Inhibitor = {
+        id: '1',
+        timestamp: ninetyDaysAgo.toISOString(),
+        trigger: {},
+        signal: 'test',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      };
+
+      const strength = calculateCurrentStrength(inhibitor);
+      expect(strength).toBeCloseTo(0.125, 2);
+    });
+
+    it('should respect custom half-life', () => {
+      const fifteenDaysAgo = new Date(Date.now() - 15 * 24 * 60 * 60 * 1000);
+      const inhibitor: Inhibitor = {
+        id: '1',
+        timestamp: fifteenDaysAgo.toISOString(),
+        trigger: {},
+        signal: 'test',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 15, // 15-day half-life instead of 30
+      };
+
+      const strength = calculateCurrentStrength(inhibitor);
+      expect(strength).toBeCloseTo(0.5, 2); // One half-life at 15 days
+    });
+  });
+
+  describe('queryInhibitors', () => {
+    it('should filter by relevance threshold (>0.2)', async () => {
+      // Fresh inhibitor (strength 1.0)
+      await emitInhibitor({
+        trigger: { file: 'test.ts', mode: 'error_reducer' },
+        signal: 'Fresh failure',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      });
+
+      // Old inhibitor (strength ~0.125 at 90 days)
+      const ninetyDaysAgo = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);
+      const oldInhibitor: Inhibitor = {
+        id: '2',
+        timestamp: ninetyDaysAgo.toISOString(),
+        trigger: { file: 'test.ts', mode: 'error_reducer' },
+        signal: 'Old failure',
+        origin: {
+          agent_id: 'a2',
+          trace_id: 't2',
+          energy_wasted: 0.01,
+          failure_type: 'regression',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      };
+
+      // Manually write old inhibitor
+      const inhibitorsFile = path.join(TEST_DIR, '_inhibitors.ndjson');
+      fs.appendFileSync(inhibitorsFile, JSON.stringify(oldInhibitor) + '\n');
+
+      const relevant = await queryInhibitors('test.ts', 'error_reducer');
+
+      // Only fresh one should be included (old one is 0.125 < 0.2)
+      expect(relevant.length).toBe(1);
+      expect(relevant[0].signal).toBe('Fresh failure');
+    });
+
+    it('should match by file', async () => {
+      await emitInhibitor({
+        trigger: { file: 'match.ts', mode: 'error_reducer' },
+        signal: 'Match',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      });
+
+      await emitInhibitor({
+        trigger: { file: 'nomatch.ts', mode: 'error_reducer' },
+        signal: 'No match',
+        origin: {
+          agent_id: 'a2',
+          trace_id: 't2',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      });
+
+      const relevant = await queryInhibitors('match.ts', 'error_reducer');
+      expect(relevant.length).toBe(1);
+      expect(relevant[0].signal).toBe('Match');
+    });
+
+    it('should match by mode', async () => {
+      await emitInhibitor({
+        trigger: { file: 'test.ts', mode: 'error_reducer' },
+        signal: 'Error reducer',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      });
+
+      await emitInhibitor({
+        trigger: { file: 'test.ts', mode: 'complexity_reducer' },
+        signal: 'Complexity reducer',
+        origin: {
+          agent_id: 'a2',
+          trace_id: 't2',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      });
+
+      const relevant = await queryInhibitors('test.ts', 'error_reducer');
+      expect(relevant.length).toBe(1);
+      expect(relevant[0].signal).toBe('Error reducer');
+    });
+
+    it('should sort by strength (strongest first)', async () => {
+      await emitInhibitor({
+        trigger: { file: 'test.ts' },
+        signal: 'Weak',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 0.3,
+        half_life_days: 30,
+      });
+
+      await emitInhibitor({
+        trigger: { file: 'test.ts' },
+        signal: 'Strong',
+        origin: {
+          agent_id: 'a2',
+          trace_id: 't2',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 0.9,
+        half_life_days: 30,
+      });
+
+      const relevant = await queryInhibitors('test.ts', 'error_reducer');
+      expect(relevant[0].signal).toBe('Strong');
+      expect(relevant[1].signal).toBe('Weak');
+    });
+  });
+
+  describe('extractFailurePattern', () => {
+    it('should extract TypeError pattern', () => {
+      const output = 'TypeError: Cannot read property x of undefined';
+      expect(extractFailurePattern(output)).toBe('changes causing TypeError');
+    });
+
+    it('should extract module import pattern', () => {
+      const output = "Error: Cannot find module './missing'";
+      expect(extractFailurePattern(output)).toBe('breaking imports');
+    });
+
+    it('should extract type assignment pattern', () => {
+      const output = 'error TS2322: Type string is not assignable to type number';
+      expect(extractFailurePattern(output)).toBe('type mismatches');
+    });
+
+    it('should return undefined for unknown patterns', () => {
+      const output = 'Some unknown error';
+      expect(extractFailurePattern(output)).toBeUndefined();
+    });
+  });
+
+  describe('gcInhibitors', () => {
+    it('should remove decayed inhibitors (strength < 0.05)', async () => {
+      // Fresh inhibitor (keep)
+      await emitInhibitor({
+        trigger: { file: 'keep.ts' },
+        signal: 'Keep me',
+        origin: {
+          agent_id: 'a1',
+          trace_id: 't1',
+          energy_wasted: 0.01,
+          failure_type: 'ci_failed',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      });
+
+      // Very old inhibitor (remove - strength ~0.03125 at 150 days, 5 half-lives)
+      // At 150 days with 30-day half-life: 0.5^5 = 0.03125 < 0.05
+      const veryOld = new Date(Date.now() - 150 * 24 * 60 * 60 * 1000);
+      const oldInhibitor: Inhibitor = {
+        id: '2',
+        timestamp: veryOld.toISOString(),
+        trigger: { file: 'remove.ts' },
+        signal: 'Remove me',
+        origin: {
+          agent_id: 'a2',
+          trace_id: 't2',
+          energy_wasted: 0.01,
+          failure_type: 'regression',
+        },
+        strength: 1.0,
+        half_life_days: 30,
+      };
+
+      const inhibitorsFile = path.join(TEST_DIR, '_inhibitors.ndjson');
+      fs.appendFileSync(inhibitorsFile, JSON.stringify(oldInhibitor) + '\n');
+
+      const result = await gcInhibitors();
+
+      expect(result.removed).toBeGreaterThan(0);
+      expect(result.kept).toBeGreaterThan(0);
+
+      const remaining = await readInhibitors();
+      expect(remaining.every(i => i.signal !== 'Remove me')).toBe(true);
+    });
+  });
+
+  describe('formatInhibitorForPrompt', () => {
+    it('should format inhibitor for display', () => {
+      const inhibitor = {
+        id: '1',
+        timestamp: new Date().toISOString(),
+        trigger: {
+          file: 'test.ts',
+          mode: 'complexity_reducer' as Mode,
+          pattern: 'removing null checks',
+        },
+        signal: 'CI failed: TypeError',
+        origin: {
+          agent_id: 'agent-123',
+          trace_id: 'trace-456',
+          energy_wasted: 0.04,
+          failure_type: 'ci_failed' as const,
+        },
+        strength: 1.0,
+        half_life_days: 30,
+        currentStrength: 0.85,
+      };
+
+      const formatted = formatInhibitorForPrompt(inhibitor);
+
+      expect(formatted).toContain('85%');
+      expect(formatted).toContain('removing null checks');
+      expect(formatted).toContain('CI failed: TypeError');
+      expect(formatted).toContain('agent-123');
+      expect(formatted).toContain('$0.0400');
+    });
+  });
+});

package/tests/coordination/integration.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Integration tests for Phase 3: Concurrency & Coordination
+ * Tests the full flow of multi-agent coordination
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import {
+  acquireLock,
+  releaseLock,
+  listLocks,
+} from '../../src/coordination/file-locks.js';
+import {
+  spawnAgent,
+  killAllAgents,
+  listAgents,
+} from '../../src/coordination/process-manager.js';
+
+const LOCK_DIR = '.agent-meta/locks';
+
+describe('Phase 3 Integration: Multi-Agent Coordination', () => {
+  beforeEach(async () => {
+    // Clean up before tests
+    killAllAgents();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    try {
+      await fs.rm(LOCK_DIR, { recursive: true, force: true });
+    } catch {
+      // Ignore
+    }
+    await fs.mkdir(LOCK_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    killAllAgents();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    try {
+      await fs.rm(LOCK_DIR, { recursive: true, force: true });
+    } catch {
+      // Ignore
+    }
+  });
+
+  it('should coordinate multiple agents working on different files', async () => {
+    const files = ['file1.ts', 'file2.ts', 'file3.ts'];
+
+    // Simulate three agents each acquiring a lock on different files
+    const locks = await Promise.all(
+      files.map((file, i) =>
+        acquireLock(file, `agent-${i + 1}`, 'error_reducer')
+      )
+    );
+
+    // All should succeed (different files)
+    expect(locks.every((l) => l === true)).toBe(true);
+
+    const activeLocks = await listLocks();
+    expect(activeLocks).toHaveLength(3);
+
+    // Clean up
+    await Promise.all(files.map((file) => releaseLock(file)));
+  });
+
+  it('should prevent multiple agents from working on the same file', async () => {
+    const file = 'contested.ts';
+
+    // Three agents try to lock the same file
+    const results = await Promise.all([
+      acquireLock(file, 'agent-1', 'error_reducer'),
+      acquireLock(file, 'agent-2', 'complexity_reducer'),
+      acquireLock(file, 'agent-3', 'debt_payer'),
+    ]);
+
+    // Only one should succeed
+    const successes = results.filter(Boolean);
+    expect(successes).toHaveLength(1);
+
+    const activeLocks = await listLocks();
+    expect(activeLocks).toHaveLength(1);
+
+    await releaseLock(file);
+  });
+
+  it('should spawn multiple agents and track them', async () => {
+    // Spawn multiple agents
+    spawnAgent({ agentId: 'worker-1', maxIterations: 5, timeout: 5000 });
+    spawnAgent({ agentId: 'worker-2', maxIterations: 5, timeout: 5000 });
+    spawnAgent({ agentId: 'worker-3', maxIterations: 5, timeout: 5000 });
+
+    // Wait a moment for them to start
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    const agents = listAgents();
+    expect(agents).toHaveLength(3);
+
+    const agentIds = agents.map((a) => a.agentId).sort();
+    expect(agentIds).toEqual(['worker-1', 'worker-2', 'worker-3']);
+
+    // All should have PIDs
+    expect(agents.every((a) => a.pid > 0)).toBe(true);
+  });
+
+  it('should handle agent lock lifecycle', async () => {
+    const file = 'work-file.ts';
+
+    // Agent acquires lock
+    const locked = await acquireLock(file, 'agent-1', 'error_reducer');
+    expect(locked).toBe(true);
+
+    // Verify lock exists
+    let locks = await listLocks();
+    expect(locks).toHaveLength(1);
+    expect(locks[0].agent_id).toBe('agent-1');
+
+    // Agent releases lock
+    const released = await releaseLock(file);
+    expect(released).toBe(true);
+
+    // Verify lock is gone
+    locks = await listLocks();
+    expect(locks).toHaveLength(0);
+
+    // Another agent can now acquire
+    const locked2 = await acquireLock(file, 'agent-2', 'complexity_reducer');
+    expect(locked2).toBe(true);
+
+    await releaseLock(file);
+  });
+
+  it('should demonstrate full coordination scenario', async () => {
+    /**
+     * Scenario: 4 agents, 3 files
+     * - Agent 1 gets file1
+     * - Agent 2 gets file2
+     * - Agent 3 gets file3
+     * - Agent 4 fails to get any (all locked)
+     * - Agent 1 releases file1
+     * - Agent 4 gets file1
+     */
+
+    const files = ['file1.ts', 'file2.ts', 'file3.ts'];
+
+    // Agents 1-3 acquire locks
+    const [lock1, lock2, lock3] = await Promise.all([
+      acquireLock(files[0], 'agent-1', 'error_reducer'),
+      acquireLock(files[1], 'agent-2', 'complexity_reducer'),
+      acquireLock(files[2], 'agent-3', 'debt_payer'),
+    ]);
+
+    expect([lock1, lock2, lock3]).toEqual([true, true, true]);
+
+    // Agent 4 tries all files, all should fail
+    const [lock4a, lock4b, lock4c] = await Promise.all([
+      acquireLock(files[0], 'agent-4', 'error_reducer'),
+      acquireLock(files[1], 'agent-4', 'error_reducer'),
+      acquireLock(files[2], 'agent-4', 'error_reducer'),
+    ]);
+
+    expect([lock4a, lock4b, lock4c]).toEqual([false, false, false]);
+
+    // Agent 1 releases file1
+    await releaseLock(files[0]);
+
+    // Agent 4 can now acquire file1
+    const lock4 = await acquireLock(files[0], 'agent-4', 'stabilizer');
+    expect(lock4).toBe(true);
+
+    // Verify final state
+    const locks = await listLocks();
+    expect(locks).toHaveLength(3);
+
+    const agentIds = locks.map((l) => l.agent_id).sort();
+    expect(agentIds).toEqual(['agent-2', 'agent-3', 'agent-4']);
+
+    // Clean up
+    await Promise.all(files.map((f) => releaseLock(f)));
+  });
+
+  it('should handle rapid lock acquire/release cycles', async () => {
+    const file = 'cycle-test.ts';
+    const cycles = 10;
+
+    for (let i = 0; i < cycles; i++) {
+      const locked = await acquireLock(file, `agent-${i}`, 'error_reducer');
+      expect(locked).toBe(true);
+
+      const released = await releaseLock(file);
+      expect(released).toBe(true);
+    }
+
+    // Should have no locks at the end
+    const locks = await listLocks();
+    expect(locks).toHaveLength(0);
+  });
+});