claude-mycelium 2.0.0 → 2.2.0

package/tests/task/planner.test.ts

@@ -0,0 +1,359 @@
+/**
+ * Tests for Task Planner
+ * Validates task decomposition and dependency analysis
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { planTask, analyzeDependencies, identifyRisks } from '../../src/task/planner.js';
+import { Task, TaskPlan, TaskStep } from '../../src/types/index.js';
+import * as llm from '../../src/llm/anthropic-client.js';
+
+// Mock LLM client
+vi.mock('../../src/llm/anthropic-client.js', () => ({
+  callLLM: vi.fn(),
+}));
+
+// Mock fast-glob
+vi.mock('fast-glob', () => ({
+  default: vi.fn(() => Promise.resolve(['src/auth.ts', 'src/api.ts'])),
+}));
+
+describe('Task Planner', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('planTask', () => {
+    it('should generate a task plan for adding health check endpoint', async () => {
+      // Mock LLM response
+      const mockPlan: TaskPlan = {
+        summary: 'Add health check endpoint to API',
+        steps: [
+          {
+            order: 1,
+            description: 'Create health check handler',
+            target_file: 'src/api/health.ts',
+            mode: 'create',
+            depends_on: [],
+            completed: false,
+          },
+          {
+            order: 2,
+            description: 'Add route to main router',
+            target_file: 'src/api/index.ts',
+            mode: 'stabilizer',
+            depends_on: [1],
+            completed: false,
+          },
+          {
+            order: 3,
+            description: 'Add health check test',
+            target_file: 'src/api/health.test.ts',
+            mode: 'create',
+            depends_on: [1],
+            completed: false,
+          },
+          {
+            order: 4,
+            description: 'Update API documentation',
+            target_file: 'src/api/docs.ts',
+            mode: 'debt_payer',
+            depends_on: [2],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: ['May need to update deployment config'],
+      };
+
+      vi.mocked(llm.callLLM).mockResolvedValue({
+        content: JSON.stringify(mockPlan),
+        usage: { inputTokens: 100, outputTokens: 200 },
+        model: 'claude-sonnet-4-5-20250929',
+      });
+
+      const task: Task = {
+        id: 'test-123',
+        description: 'Add health check endpoint',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 0,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const plan = await planTask(task);
+
+      expect(plan.steps.length).toBe(4);
+      expect(plan.steps[0].mode).toBe('create');
+      expect(plan.steps[0].target_file).toContain('health.ts');
+      expect(plan.estimated_complexity).toBe('small');
+      expect(llm.callLLM).toHaveBeenCalledOnce();
+    });
+
+    it('should handle complex task with multiple dependencies', async () => {
+      const mockPlan: TaskPlan = {
+        summary: 'Add JWT authentication',
+        steps: [
+          {
+            order: 1,
+            description: 'Create JWT utility',
+            target_file: 'src/auth/jwt.ts',
+            mode: 'create',
+            depends_on: [],
+            completed: false,
+          },
+          {
+            order: 2,
+            description: 'Create auth middleware',
+            target_file: 'src/auth/middleware.ts',
+            mode: 'create',
+            depends_on: [1],
+            completed: false,
+          },
+          {
+            order: 3,
+            description: 'Update user routes',
+            target_file: 'src/api/user.ts',
+            mode: 'stabilizer',
+            depends_on: [2],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'medium',
+        risks: ['Breaking change for existing API clients'],
+      };
+
+      vi.mocked(llm.callLLM).mockResolvedValue({
+        content: JSON.stringify(mockPlan),
+        usage: { inputTokens: 150, outputTokens: 300 },
+        model: 'claude-sonnet-4-5-20250929',
+      });
+
+      const task: Task = {
+        id: 'test-456',
+        description: 'Add JWT authentication',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 0,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const plan = await planTask(task);
+
+      expect(plan.steps.length).toBe(3);
+      expect(plan.steps[1].depends_on).toContain(1);
+      expect(plan.steps[2].depends_on).toContain(2);
+    });
+
+    it('should throw error if LLM returns invalid JSON', async () => {
+      vi.mocked(llm.callLLM).mockResolvedValue({
+        content: 'This is not JSON',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        model: 'claude-sonnet-4-5-20250929',
+      });
+
+      const task: Task = {
+        id: 'test-789',
+        description: 'Invalid task',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 0,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      await expect(planTask(task)).rejects.toThrow('Failed to parse task plan');
+    });
+  });
+
+  describe('analyzeDependencies', () => {
+    it('should identify direct dependencies', () => {
+      const steps: TaskStep[] = [
+        {
+          order: 1,
+          description: 'Step 1',
+          target_file: 'src/a.ts',
+          mode: 'create',
+          depends_on: [],
+          completed: false,
+        },
+        {
+          order: 2,
+          description: 'Step 2',
+          target_file: 'src/b.ts',
+          mode: 'create',
+          depends_on: [1],
+          completed: false,
+        },
+        {
+          order: 3,
+          description: 'Step 3',
+          target_file: 'src/c.ts',
+          mode: 'create',
+          depends_on: [1, 2],
+          completed: false,
+        },
+      ];
+
+      const deps = analyzeDependencies(steps);
+
+      expect(deps.get(1)).toEqual([]);
+      expect(deps.get(2)).toContain(1);
+      expect(deps.get(3)).toContain(1);
+      expect(deps.get(3)).toContain(2);
+    });
+
+    it('should detect implicit dependencies for modify steps', () => {
+      const steps: TaskStep[] = [
+        {
+          order: 1,
+          description: 'Create file',
+          target_file: 'src/auth.ts',
+          mode: 'create',
+          depends_on: [],
+          completed: false,
+        },
+        {
+          order: 2,
+          description: 'Modify file',
+          target_file: 'src/auth.ts',
+          mode: 'error_reducer',
+          depends_on: [],
+          completed: false,
+        },
+      ];
+
+      const deps = analyzeDependencies(steps);
+
+      // Step 2 should implicitly depend on step 1
+      expect(deps.get(2)).toContain(1);
+    });
+
+    it('should detect test file dependencies', () => {
+      const steps: TaskStep[] = [
+        {
+          order: 1,
+          description: 'Create implementation',
+          target_file: 'src/auth.ts',
+          mode: 'create',
+          depends_on: [],
+          completed: false,
+        },
+        {
+          order: 2,
+          description: 'Create test',
+          target_file: 'src/auth.test.ts',
+          mode: 'create',
+          depends_on: [],
+          completed: false,
+        },
+      ];
+
+      const deps = analyzeDependencies(steps);
+
+      // Test file should implicitly depend on implementation
+      expect(deps.get(2)).toContain(1);
+    });
+  });
+
+  describe('identifyRisks', () => {
+    it('should identify circular dependencies', () => {
+      const plan: TaskPlan = {
+        summary: 'Test plan',
+        steps: [
+          {
+            order: 1,
+            description: 'Step 1',
+            target_file: 'src/a.ts',
+            mode: 'create',
+            depends_on: [2],
+            completed: false,
+          },
+          {
+            order: 2,
+            description: 'Step 2',
+            target_file: 'src/b.ts',
+            mode: 'create',
+            depends_on: [1],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: [],
+      };
+
+      const risks = identifyRisks(plan);
+
+      expect(risks).toContain('Circular dependency detected in task steps');
+    });
+
+    it('should identify steps with many dependencies', () => {
+      const plan: TaskPlan = {
+        summary: 'Test plan',
+        steps: [
+          {
+            order: 1,
+            description: 'Step 1',
+            target_file: 'src/a.ts',
+            mode: 'create',
+            depends_on: [2, 3, 4, 5],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: [],
+      };
+
+      const risks = identifyRisks(plan);
+
+      expect(risks.some(r => r.includes('complex dependencies'))).toBe(true);
+    });
+
+    it('should identify large tasks with many steps', () => {
+      const steps: TaskStep[] = Array.from({ length: 12 }, (_, i) => ({
+        order: i + 1,
+        description: `Step ${i + 1}`,
+        target_file: `src/file${i + 1}.ts`,
+        mode: 'create' as const,
+        depends_on: [],
+        completed: false,
+      }));
+
+      const plan: TaskPlan = {
+        summary: 'Large task',
+        steps,
+        estimated_complexity: 'large',
+        risks: [],
+      };
+
+      const risks = identifyRisks(plan);
+
+      expect(risks.some(r => r.includes('Large task'))).toBe(true);
+    });
+
+    it('should keep existing risks from plan', () => {
+      const plan: TaskPlan = {
+        summary: 'Test plan',
+        steps: [],
+        estimated_complexity: 'small',
+        risks: ['Existing risk 1', 'Existing risk 2'],
+      };
+
+      const risks = identifyRisks(plan);
+
+      expect(risks).toContain('Existing risk 1');
+      expect(risks).toContain('Existing risk 2');
+    });
+  });
+});

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

@@ -53,11 +53,21 @@ describe('Trace Event System', () => {
         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,
+        metabolic_cost: 0.05,
+        efficiency: 4.0,
+        ci_passed: true,
+        changes: {
+          additions: 5,
+          deletions: 2,
+          files_touched: ['src/test.ts'],
+        },
+        notes: ['fix null check', 'add error handling'],
+        cost: {
+          tokens_in: 500,
+          tokens_out: 500,
+          model: 'claude-sonnet-4',
+          estimated_usd: 0.05,
+        },
       };
 
       await recordTrace(trace);
@@ -82,11 +92,21 @@ describe('Trace Event System', () => {
         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,
+        metabolic_cost: 0.03,
+        efficiency: 6.67,
+        ci_passed: true,
+        changes: {
+          additions: 3,
+          deletions: 1,
+          files_touched: ['src/auth.ts'],
+        },
+        notes: ['extract function'],
+        cost: {
+          tokens_in: 400,
+          tokens_out: 400,
+          model: 'claude-sonnet-4',
+          estimated_usd: 0.03,
+        },
       };
 
       await recordTrace(trace);
@@ -102,11 +122,22 @@ describe('Trace Event System', () => {
         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,
+        gradient_delta: 0.1,
+        metabolic_cost: 0.02,
+        efficiency: 5.0,
+        ci_passed: true,
+        changes: {
+          additions: 2,
+          deletions: 1,
+          files_touched: ['src/test1.ts'],
+        },
+        notes: ['fix lint'],
+        cost: {
+          tokens_in: 250,
+          tokens_out: 250,
+          model: 'claude-sonnet-4',
+          estimated_usd: 0.02,
+        },
       });
 
       const trace2: TraceEvent = createTraceEvent({
@@ -115,11 +146,22 @@ describe('Trace Event System', () => {
         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,
+        gradient_delta: 0.1,
+        metabolic_cost: 0.025,
+        efficiency: 4.0,
+        ci_passed: true,
+        changes: {
+          additions: 5,
+          deletions: 0,
+          files_touched: ['src/test2.ts'],
+        },
+        notes: ['add tests'],
+        cost: {
+          tokens_in: 300,
+          tokens_out: 300,
+          model: 'claude-sonnet-4',
+          estimated_usd: 0.025,
+        },
       });
 
       await recordTrace(trace1);

package/tsconfig.json

@@ -14,8 +14,8 @@
     "declaration": true,
     "declarationMap": true,
     "sourceMap": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true
   },