claude-mycelium 2.0.0 → 2.1.0

package/tests/task/executor.test.ts

@@ -0,0 +1,421 @@
+/**
+ * Tests for Task Executor
+ * Validates multi-step execution and progress tracking
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { executeTask, executeStep, trackProgress } from '../../src/task/executor.js';
+import { Task, TaskPlan } from '../../src/types/index.js';
+import * as llm from '../../src/llm/anthropic-client.js';
+import * as fileUtils from '../../src/utils/file-utils.js';
+import * as ciProvider from '../../src/utils/ci-provider.js';
+import * as traceEvent from '../../src/trace/trace-event.js';
+
+// Mock dependencies
+vi.mock('../../src/llm/anthropic-client.js', () => ({
+  callLLM: vi.fn(),
+  calculateCost: vi.fn(),
+}));
+vi.mock('../../src/utils/file-utils.js', () => ({
+  fileExists: vi.fn(),
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+}));
+vi.mock('../../src/utils/ci-provider.js', () => ({
+  runCI: vi.fn(),
+}));
+vi.mock('../../src/trace/trace-event.js', () => ({
+  recordTrace: vi.fn(),
+}));
+vi.mock('../../src/core/signals/index.js', () => ({
+  calculateFileMetrics: vi.fn(() => Promise.resolve({
+    path: 'test.ts',
+    complexity: 0.3,
+    churn: 0.2,
+    error_rate: 0.1,
+    debt: 0.2,
+    centrality: 0.4,
+    loc: 100,
+  })),
+}));
+vi.mock('../../src/core/gradient.js', () => ({
+  calculateGradient: vi.fn(() => ({ score: 0.5 })),
+}));
+
+describe('Task Executor', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Default mocks
+    vi.mocked(ciProvider.runCI).mockResolvedValue({
+      passed: true,
+      output: 'All checks passed',
+    });
+
+    vi.mocked(traceEvent.recordTrace).mockResolvedValue(undefined);
+
+    vi.mocked(llm.callLLM).mockResolvedValue({
+      content: '```typescript\nexport function test() {}\n```',
+      usage: { inputTokens: 100, outputTokens: 200 },
+      model: 'claude-sonnet-4-5-20250929',
+    });
+
+    vi.mocked(llm.calculateCost).mockReturnValue(0.05);
+  });
+
+  describe('executeTask', () => {
+    it('should execute all steps in dependency order', async () => {
+      const plan: TaskPlan = {
+        summary: 'Test task',
+        steps: [
+          {
+            order: 1,
+            description: 'Create file A',
+            target_file: 'src/a.ts',
+            mode: 'create',
+            depends_on: [],
+            completed: false,
+          },
+          {
+            order: 2,
+            description: 'Create file B',
+            target_file: 'src/b.ts',
+            mode: 'create',
+            depends_on: [1],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: [],
+      };
+
+      const task: Task = {
+        id: 'test-123',
+        description: 'Test task',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        plan,
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 2,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      vi.mocked(fileUtils.fileExists).mockReturnValue(false);
+
+      const result = await executeTask(task);
+
+      expect(result.status).toBe('completed');
+      expect(result.steps_completed).toBe(2);
+      expect(result.files_created).toHaveLength(2);
+    });
+
+    it('should stop execution on step failure', async () => {
+      const plan: TaskPlan = {
+        summary: 'Test task',
+        steps: [
+          {
+            order: 1,
+            description: 'Create file',
+            target_file: 'src/a.ts',
+            mode: 'create',
+            depends_on: [],
+            completed: false,
+          },
+          {
+            order: 2,
+            description: 'Another step',
+            target_file: 'src/b.ts',
+            mode: 'create',
+            depends_on: [1],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: [],
+      };
+
+      const task: Task = {
+        id: 'test-456',
+        description: 'Test task',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        plan,
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 2,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      vi.mocked(fileUtils.fileExists).mockReturnValue(false);
+      vi.mocked(ciProvider.runCI).mockResolvedValueOnce({
+        passed: false,
+        output: 'CI failed',
+      });
+
+      const result = await executeTask(task);
+
+      expect(result.status).toBe('failed');
+      expect(result.steps_completed).toBe(0);
+      expect(result.error).toContain('CI failed');
+    });
+
+    it('should handle parallel steps correctly', async () => {
+      const plan: TaskPlan = {
+        summary: 'Test task',
+        steps: [
+          {
+            order: 1,
+            description: 'Create base file',
+            target_file: 'src/base.ts',
+            mode: 'create',
+            depends_on: [],
+            completed: false,
+          },
+          {
+            order: 2,
+            description: 'Create file A',
+            target_file: 'src/a.ts',
+            mode: 'create',
+            depends_on: [1],
+            completed: false,
+          },
+          {
+            order: 3,
+            description: 'Create file B',
+            target_file: 'src/b.ts',
+            mode: 'create',
+            depends_on: [1],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: [],
+      };
+
+      const task: Task = {
+        id: 'test-789',
+        description: 'Test task',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        plan,
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 3,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      vi.mocked(fileUtils.fileExists).mockReturnValue(false);
+
+      const result = await executeTask(task);
+
+      // Steps 2 and 3 should execute in parallel (both depend only on 1)
+      expect(result.status).toBe('completed');
+      expect(result.steps_completed).toBe(3);
+    });
+  });
+
+  describe('executeStep', () => {
+    it('should execute create mode step', async () => {
+      const task: Task = {
+        id: 'test-123',
+        description: 'Test',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 1,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const step = {
+        order: 1,
+        description: 'Create new file',
+        target_file: 'src/new.ts',
+        mode: 'create' as const,
+        depends_on: [],
+        completed: false,
+      };
+
+      vi.mocked(fileUtils.fileExists).mockReturnValue(false);
+
+      const result = await executeStep(task, step);
+
+      expect(result.success).toBe(true);
+      expect(result.trace_id).toBeDefined();
+      expect(fileUtils.writeFile).toHaveBeenCalled();
+    });
+
+    it('should fail create if file already exists', async () => {
+      const task: Task = {
+        id: 'test-456',
+        description: 'Test',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 1,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const step = {
+        order: 1,
+        description: 'Create file',
+        target_file: 'src/existing.ts',
+        mode: 'create' as const,
+        depends_on: [],
+        completed: false,
+      };
+
+      vi.mocked(fileUtils.fileExists).mockReturnValue(true);
+
+      const result = await executeStep(task, step);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('already exists');
+    });
+
+    it('should execute modify mode step', async () => {
+      const task: Task = {
+        id: 'test-789',
+        description: 'Test',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 1,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const step = {
+        order: 1,
+        description: 'Fix errors',
+        target_file: 'src/existing.ts',
+        mode: 'error_reducer' as const,
+        depends_on: [],
+        completed: false,
+      };
+
+      vi.mocked(fileUtils.fileExists).mockReturnValue(true);
+      vi.mocked(fileUtils.readFile).mockReturnValue('original content');
+
+      const result = await executeStep(task, step);
+
+      expect(result.success).toBe(true);
+      expect(result.trace_id).toBeDefined();
+    });
+
+    it('should revert changes if CI fails', async () => {
+      const task: Task = {
+        id: 'test-999',
+        description: 'Test',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 1,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const step = {
+        order: 1,
+        description: 'Modify file',
+        target_file: 'src/test.ts',
+        mode: 'debt_payer' as const,
+        depends_on: [],
+        completed: false,
+      };
+
+      const originalContent = 'original';
+      vi.mocked(fileUtils.fileExists).mockReturnValue(true);
+      vi.mocked(fileUtils.readFile).mockReturnValue(originalContent);
+      vi.mocked(ciProvider.runCI).mockResolvedValue({
+        passed: false,
+        output: 'Tests failed',
+      });
+
+      const result = await executeStep(task, step);
+
+      expect(result.success).toBe(false);
+      // Should revert to original content
+      expect(fileUtils.writeFile).toHaveBeenCalledWith('src/test.ts', originalContent);
+    });
+  });
+
+  describe('trackProgress', () => {
+    it('should calculate progress percentage', () => {
+      const task: Task = {
+        id: 'test-123',
+        description: 'Test',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 3,
+        steps_total: 10,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const progress = trackProgress(task);
+
+      expect(progress.percentage).toBe(30);
+      expect(progress.completed).toBe(3);
+      expect(progress.total).toBe(10);
+      expect(progress.status).toBe('in_progress');
+    });
+
+    it('should handle zero total steps', () => {
+      const task: Task = {
+        id: 'test-456',
+        description: 'Test',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 0,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const progress = trackProgress(task);
+
+      expect(progress.percentage).toBe(0);
+    });
+
+    it('should show 100% for completed task', () => {
+      const task: Task = {
+        id: 'test-789',
+        description: 'Test',
+        status: 'completed',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 5,
+        steps_total: 5,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const progress = trackProgress(task);
+
+      expect(progress.percentage).toBe(100);
+      expect(progress.status).toBe('completed');
+    });
+  });
+});