claude-mycelium 2.0.0 → 2.1.0

package/tests/cli/status.test.ts

@@ -0,0 +1,282 @@
+/**
+ * Status CLI Command Tests
+ *
+ * Tests for system status command
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { fileExists } from '../../src/utils/file-utils.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Use a temporary test directory
+const testDir = path.join(__dirname, '../../.test-status');
+
+describe('Status Command', () => {
+  beforeEach(async () => {
+    // Clean up test directory
+    if (fileExists(testDir)) {
+      await fs.rm(testDir, { recursive: true });
+    }
+    await fs.mkdir(testDir, { recursive: true });
+    await fs.mkdir(path.join(testDir, '.agent-meta'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up test directory
+    if (fileExists(testDir)) {
+      await fs.rm(testDir, { recursive: true });
+    }
+  });
+
+  it('should read system config', async () => {
+    const configPath = path.join(testDir, '.agent-meta/_config.json');
+
+    const config = {
+      version: '2.0.0',
+      created_at: new Date().toISOString(),
+      error_provider: 'file',
+      error_file: '.agent-meta/_errors.json',
+      ci_command: 'npm test',
+      spawn_count: 42,
+      last_gc_at_spawn: 0,
+    };
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+    const content = await fs.readFile(configPath, 'utf-8');
+    const loaded = JSON.parse(content);
+
+    expect(loaded.version).toBe('2.0.0');
+    expect(loaded.spawn_count).toBe(42);
+  });
+
+  it('should count trace events', async () => {
+    const tracesDir = path.join(testDir, '.agent-meta/traces');
+    await fs.mkdir(tracesDir, { recursive: true });
+
+    // Create a trace file with events
+    const traceFile = path.join(tracesDir, 'file1.ts.ndjson');
+    const events = [
+      {
+        id: 'event1',
+        timestamp: new Date().toISOString(),
+        file_path: 'file1.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.5,
+        gradient_after: 0.6,
+        gradient_delta: 0.1,
+        metabolic_cost: 0.01,
+        efficiency: 0.8,
+        ci_passed: true,
+        changes: { additions: 10, deletions: 5, files_touched: ['file1.ts'] },
+        notes: [],
+        cost: {
+          tokens_in: 100,
+          tokens_out: 50,
+          model: 'claude-3-sonnet',
+          estimated_usd: 0.01,
+        },
+      },
+      {
+        id: 'event2',
+        timestamp: new Date().toISOString(),
+        file_path: 'file1.ts',
+        mode: 'error_reducer',
+        gradient_before: 0.6,
+        gradient_after: 0.7,
+        gradient_delta: 0.1,
+        metabolic_cost: 0.01,
+        efficiency: 0.9,
+        ci_passed: true,
+        changes: { additions: 8, deletions: 3, files_touched: ['file1.ts'] },
+        notes: [],
+        cost: {
+          tokens_in: 95,
+          tokens_out: 48,
+          model: 'claude-3-sonnet',
+          estimated_usd: 0.01,
+        },
+      },
+    ];
+
+    const content = events.map(e => JSON.stringify(e)).join('\n') + '\n';
+    await fs.writeFile(traceFile, content);
+
+    // Count events
+    const fileContent = await fs.readFile(traceFile, 'utf-8');
+    const lines = fileContent.split('\n').filter(Boolean);
+
+    expect(lines).toHaveLength(2);
+  });
+
+  it('should count quarantine entries', async () => {
+    const quarantinePath = path.join(testDir, '.agent-meta/_quarantine.json');
+
+    const quarantine = {
+      updated_at: new Date().toISOString(),
+      entries: [
+        {
+          file: 'problematic.ts',
+          quarantined_at: new Date().toISOString(),
+          reason: 'Too many failures',
+          attempts_before_quarantine: 3,
+          explorer_attempts: 0,
+          max_explorer_attempts: 3,
+        },
+      ],
+    };
+
+    await fs.writeFile(quarantinePath, JSON.stringify(quarantine, null, 2));
+
+    const content = await fs.readFile(quarantinePath, 'utf-8');
+    const loaded = JSON.parse(content);
+
+    expect(loaded.entries).toHaveLength(1);
+  });
+
+  it('should count inhibitors', async () => {
+    const inhibitorsPath = path.join(testDir, '.agent-meta/_inhibitors.ndjson');
+
+    const inhibitors = [
+      {
+        id: 'inh1',
+        timestamp: new Date().toISOString(),
+        trigger: { file: 'file1.ts', mode: 'error_reducer' },
+        signal: 'pattern matches known bad pattern',
+        origin: {
+          agent_id: 'agent1',
+          trace_id: 'trace1',
+          energy_wasted: 0.05,
+          failure_type: 'ci_failed' as const,
+        },
+        strength: 0.8,
+        half_life_days: 7,
+      },
+      {
+        id: 'inh2',
+        timestamp: new Date().toISOString(),
+        trigger: { file: 'file2.ts', mode: 'complexity_reducer' },
+        signal: 'reverted too many times',
+        origin: {
+          agent_id: 'agent2',
+          trace_id: 'trace2',
+          energy_wasted: 0.03,
+          failure_type: 'reverted' as const,
+        },
+        strength: 0.6,
+        half_life_days: 7,
+      },
+    ];
+
+    const content = inhibitors.map(i => JSON.stringify(i)).join('\n') + '\n';
+    await fs.writeFile(inhibitorsPath, content);
+
+    const fileContent = await fs.readFile(inhibitorsPath, 'utf-8');
+    const lines = fileContent.split('\n').filter(Boolean);
+
+    expect(lines).toHaveLength(2);
+  });
+
+  it('should count errors', async () => {
+    const errorsPath = path.join(testDir, '.agent-meta/_errors.json');
+
+    const errors = {
+      updated_at: new Date().toISOString(),
+      errors: [
+        {
+          file: 'file1.ts',
+          count: 3,
+          types: ['SyntaxError', 'RuntimeError'],
+        },
+        {
+          file: 'file2.ts',
+          count: 1,
+          types: ['TypeError'],
+        },
+      ],
+    };
+
+    await fs.writeFile(errorsPath, JSON.stringify(errors, null, 2));
+
+    const content = await fs.readFile(errorsPath, 'utf-8');
+    const loaded = JSON.parse(content);
+
+    expect(loaded.errors).toHaveLength(2);
+  });
+
+  it('should calculate spawns since last GC', async () => {
+    const configPath = path.join(testDir, '.agent-meta/_config.json');
+
+    const config = {
+      version: '2.0.0',
+      created_at: new Date().toISOString(),
+      error_provider: 'file',
+      error_file: '.agent-meta/_errors.json',
+      ci_command: 'npm test',
+      spawn_count: 150,
+      last_gc_at_spawn: 100,
+    };
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+    const content = await fs.readFile(configPath, 'utf-8');
+    const loaded = JSON.parse(content);
+
+    const spawnsSinceGC = loaded.spawn_count - loaded.last_gc_at_spawn;
+
+    expect(spawnsSinceGC).toBe(50);
+  });
+
+  it('should retrieve recent activity', async () => {
+    const tracesDir = path.join(testDir, '.agent-meta/traces');
+    await fs.mkdir(tracesDir, { recursive: true });
+
+    // Create multiple trace files
+    const events = [];
+    for (let i = 0; i < 5; i++) {
+      events.push({
+        id: `event${i}`,
+        timestamp: new Date(Date.now() - i * 1000).toISOString(),
+        file_path: `file${i}.ts`,
+        mode: i % 2 === 0 ? 'error_reducer' : 'complexity_reducer',
+        gradient_before: 0.5,
+        gradient_after: 0.6,
+        gradient_delta: 0.1,
+        metabolic_cost: 0.01,
+        efficiency: 0.8,
+        ci_passed: true,
+        changes: { additions: 10, deletions: 5, files_touched: [`file${i}.ts`] },
+        notes: [],
+        cost: {
+          tokens_in: 100,
+          tokens_out: 50,
+          model: 'claude-3-sonnet',
+          estimated_usd: 0.01,
+        },
+      });
+    }
+
+    const traceFile = path.join(tracesDir, 'activity.ndjson');
+    const content = events.map(e => JSON.stringify(e)).join('\n') + '\n';
+    await fs.writeFile(traceFile, content);
+
+    const fileContent = await fs.readFile(traceFile, 'utf-8');
+    const lines = fileContent.split('\n').filter(Boolean);
+    const loaded = lines.map(l => JSON.parse(l));
+
+    // Sort by timestamp descending
+    loaded.sort(
+      (a: any, b: any) =>
+        new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+
+    expect(loaded).toHaveLength(5);
+    expect(loaded[0].file_path).toBe('file0.ts');
+  });
+});

package/tests/coordination/file-locks.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Tests for file-based locking mechanism
+ * Ensures atomic lock acquisition and proper expiration handling
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import {
+  acquireLock,
+  releaseLock,
+  checkLock,
+  listLocks,
+  cleanupStaleLocks,
+} from '../../src/coordination/file-locks.js';
+import type { Mode } from '../../src/types/index.js';
+
+const LOCK_DIR = '.agent-meta/locks';
+const TEST_FILE = 'test-file.ts';
+
+describe('File Locking', () => {
+  beforeEach(async () => {
+    // Clean up locks directory before each test
+    try {
+      await fs.rm(LOCK_DIR, { recursive: true, force: true });
+    } catch {
+      // Ignore if doesn't exist
+    }
+    await fs.mkdir(LOCK_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up after tests
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    try {
+      await fs.rm(LOCK_DIR, { recursive: true, force: true });
+    } catch {
+      // Ignore
+    }
+  });
+
+  it('should acquire a lock successfully', async () => {
+    const result = await acquireLock(TEST_FILE, 'agent-1', 'error_reducer');
+    expect(result).toBe(true);
+
+    const lock = await checkLock(TEST_FILE);
+    expect(lock).not.toBeNull();
+    expect(lock?.agent_id).toBe('agent-1');
+    expect(lock?.file).toBe(TEST_FILE);
+    expect(lock?.mode).toBe('error_reducer');
+    expect(lock?.pid).toBe(process.pid);
+  });
+
+  it('should prevent race conditions - exactly one agent wins', async () => {
+    // Simulate two agents racing for the same file
+    const [result1, result2] = await Promise.all([
+      acquireLock(TEST_FILE, 'agent-1', 'error_reducer'),
+      acquireLock(TEST_FILE, 'agent-2', 'error_reducer'),
+    ]);
+
+    // Exactly one should succeed
+    const successes = [result1, result2].filter(Boolean);
+    expect(successes).toHaveLength(1);
+
+    // Check which agent got the lock
+    const lock = await checkLock(TEST_FILE);
+    expect(lock).not.toBeNull();
+    expect(['agent-1', 'agent-2']).toContain(lock?.agent_id);
+  });
+
+  it('should release a lock successfully', async () => {
+    await acquireLock(TEST_FILE, 'agent-1', 'error_reducer');
+
+    const released = await releaseLock(TEST_FILE);
+    expect(released).toBe(true);
+
+    const lock = await checkLock(TEST_FILE);
+    expect(lock).toBeNull();
+  });
+
+  it('should fail to acquire an already locked file', async () => {
+    const result1 = await acquireLock(TEST_FILE, 'agent-1', 'error_reducer');
+    expect(result1).toBe(true);
+
+    const result2 = await acquireLock(TEST_FILE, 'agent-2', 'complexity_reducer');
+    expect(result2).toBe(false);
+  });
+
+  it('should detect expired locks (5-minute timeout)', async () => {
+    // Create a lock file manually with expired timestamp
+    const lockPath = path.join(LOCK_DIR, 'test-file_ts.lock');
+    const expiredLock = {
+      agent_id: 'agent-old',
+      file: TEST_FILE,
+      mode: 'error_reducer' as Mode,
+      acquired_at: new Date(Date.now() - 10 * 60 * 1000).toISOString(), // 10 mins ago
+      expires_at: new Date(Date.now() - 5 * 60 * 1000).toISOString(), // Expired 5 mins ago
+      pid: 99999, // Non-existent PID
+    };
+
+    await fs.writeFile(lockPath, JSON.stringify(expiredLock, null, 2));
+
+    // Check should return null for expired lock
+    const lock = await checkLock(TEST_FILE);
+    expect(lock).toBeNull();
+
+    // Should be able to acquire
+    const result = await acquireLock(TEST_FILE, 'agent-new', 'error_reducer');
+    expect(result).toBe(true);
+  });
+
+  it('should handle dead process takeover', async () => {
+    // Create a lock file with a dead process PID
+    const lockPath = path.join(LOCK_DIR, 'test-file_ts.lock');
+    const deadProcessLock = {
+      agent_id: 'agent-old',
+      file: TEST_FILE,
+      mode: 'error_reducer' as Mode,
+      acquired_at: new Date().toISOString(),
+      expires_at: new Date(Date.now() + 5 * 60 * 1000).toISOString(), // Not expired
+      pid: 99999, // Non-existent PID
+    };
+
+    await fs.writeFile(lockPath, JSON.stringify(deadProcessLock, null, 2));
+
+    // Check should return null for dead process
+    const lock = await checkLock(TEST_FILE);
+    expect(lock).toBeNull();
+
+    // Should be able to take over
+    const result = await acquireLock(TEST_FILE, 'agent-new', 'error_reducer');
+    expect(result).toBe(true);
+
+    // Verify new agent has the lock
+    const newLock = await checkLock(TEST_FILE);
+    expect(newLock?.agent_id).toBe('agent-new');
+  });
+
+  it('should list all active locks', async () => {
+    await acquireLock('file1.ts', 'agent-1', 'error_reducer');
+    await acquireLock('file2.ts', 'agent-2', 'complexity_reducer');
+    await acquireLock('file3.ts', 'agent-3', 'debt_payer');
+
+    const locks = await listLocks();
+    expect(locks).toHaveLength(3);
+
+    const agentIds = locks.map((l) => l.agent_id).sort();
+    expect(agentIds).toEqual(['agent-1', 'agent-2', 'agent-3']);
+  });
+
+  it('should clean up stale locks', async () => {
+    // Create one valid lock
+    await acquireLock('file1.ts', 'agent-1', 'error_reducer');
+
+    // Create expired lock manually
+    const expiredLockPath = path.join(LOCK_DIR, 'file2_ts.lock');
+    const expiredLock = {
+      agent_id: 'agent-old',
+      file: 'file2.ts',
+      mode: 'error_reducer' as Mode,
+      acquired_at: new Date(Date.now() - 10 * 60 * 1000).toISOString(),
+      expires_at: new Date(Date.now() - 5 * 60 * 1000).toISOString(),
+      pid: 99999,
+    };
+    await fs.writeFile(expiredLockPath, JSON.stringify(expiredLock, null, 2));
+
+    const cleaned = await cleanupStaleLocks();
+    expect(cleaned).toBe(1);
+
+    // Should only have the valid lock now
+    const locks = await listLocks();
+    expect(locks).toHaveLength(1);
+    expect(locks[0].agent_id).toBe('agent-1');
+  });
+
+  it('should include task_id in lock if provided', async () => {
+    await acquireLock(TEST_FILE, 'agent-1', 'error_reducer', 'task-123');
+
+    const lock = await checkLock(TEST_FILE);
+    expect(lock?.task_id).toBe('task-123');
+  });
+
+  it('should handle concurrent lock attempts on different files', async () => {
+    const results = await Promise.all([
+      acquireLock('file1.ts', 'agent-1', 'error_reducer'),
+      acquireLock('file2.ts', 'agent-2', 'complexity_reducer'),
+      acquireLock('file3.ts', 'agent-3', 'debt_payer'),
+    ]);
+
+    // All should succeed since they're different files
+    expect(results.every((r) => r === true)).toBe(true);
+
+    const locks = await listLocks();
+    expect(locks).toHaveLength(3);
+  });
+});