claude-mycelium 2.0.0 → 2.2.0

package/src/task/acceptance.ts

@@ -0,0 +1,267 @@
+/**
+ * Acceptance Criteria Validation
+ * Per ROADMAP §Phase 5 Week 6 Day 5-6: Acceptance Criteria
+ *
+ * Validates task completion against acceptance criteria including
+ * file existence, test execution, lint checks, and custom validation.
+ */
+
+import { Task, AcceptanceCriterion } from '../types/index.js';
+import { fileExists } from '../utils/file-utils.js';
+import { logDebug, logError } from '../utils/logger.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+/**
+ * Validate all acceptance criteria for a task
+ */
+export async function validateAcceptance(task: Task): Promise<boolean> {
+  logDebug('Validating acceptance criteria', {
+    taskId: task.id,
+    criteriaCount: task.acceptance_criteria.length,
+  });
+
+  let allMet = true;
+
+  for (const criterion of task.acceptance_criteria) {
+    const met = await validateCriterion(criterion);
+    criterion.met = met;
+
+    if (!met) {
+      allMet = false;
+      logDebug('Acceptance criterion not met', {
+        taskId: task.id,
+        type: criterion.type,
+        description: criterion.description,
+      });
+    }
+  }
+
+  logDebug('Acceptance validation complete', {
+    taskId: task.id,
+    allMet,
+    metCount: task.acceptance_criteria.filter(c => c.met).length,
+  });
+
+  return allMet;
+}
+
+/**
+ * Validate a single acceptance criterion
+ */
+async function validateCriterion(criterion: AcceptanceCriterion): Promise<boolean> {
+  try {
+    switch (criterion.type) {
+      case 'file_exists':
+        return await checkFileExists(criterion.check);
+
+      case 'test_passes':
+        return await runTests(criterion.check);
+
+      case 'no_lint_errors':
+        return await checkLintErrors(criterion.check);
+
+      case 'custom':
+        return await runCustomValidation(criterion.check);
+
+      default:
+        logError('Unknown criterion type', new Error('Invalid type'), {
+          type: criterion.type,
+        });
+        return false;
+    }
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Criterion validation failed', errorObj, {
+      type: criterion.type,
+      check: criterion.check,
+    });
+    return false;
+  }
+}
+
+/**
+ * Check if a file exists
+ */
+export async function checkFileExists(filePath: string): Promise<boolean> {
+  const exists = fileExists(filePath);
+  logDebug('File existence check', { filePath, exists });
+  return exists;
+}
+
+/**
+ * Run specific tests and check if they pass
+ */
+export async function runTests(testPattern: string): Promise<boolean> {
+  logDebug('Running tests', { pattern: testPattern });
+
+  try {
+    // Run vitest with specific pattern
+    const command = `npm test -- --run ${testPattern}`;
+    const { stdout, stderr } = await execAsync(command, {
+      timeout: 60000, // 60 second timeout
+    });
+
+    // Check for test failures in output
+    const output = stdout + stderr;
+    const hasFailed = output.includes('FAILED') ||
+                     output.includes('failed') ||
+                     output.includes('Error:');
+
+    logDebug('Test execution result', {
+      pattern: testPattern,
+      passed: !hasFailed,
+    });
+
+    return !hasFailed;
+  } catch (error) {
+    // exec throws on non-zero exit code
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Test execution failed', errorObj, { pattern: testPattern });
+    return false;
+  }
+}
+
+/**
+ * Check if file has lint errors
+ */
+async function checkLintErrors(filePath: string): Promise<boolean> {
+  logDebug('Checking lint errors', { filePath });
+
+  try {
+    // Run eslint on specific file
+    const command = `npx eslint ${filePath} --format json`;
+    const { stdout } = await execAsync(command, {
+      timeout: 30000, // 30 second timeout
+    });
+
+    // Parse eslint JSON output
+    const results = JSON.parse(stdout);
+
+    // Check if there are any errors
+    const totalErrors = results.reduce(
+      (sum: number, result: any) => sum + result.errorCount,
+      0
+    );
+
+    const noErrors = totalErrors === 0;
+    logDebug('Lint check result', {
+      filePath,
+      errors: totalErrors,
+      passed: noErrors,
+    });
+
+    return noErrors;
+  } catch (error) {
+    // eslint returns non-zero exit code when errors found
+    // Try to parse the output to get error count
+    if (error instanceof Error && 'stdout' in error) {
+      try {
+        const results = JSON.parse((error as any).stdout);
+        const totalErrors = results.reduce(
+          (sum: number, result: any) => sum + result.errorCount,
+          0
+        );
+        return totalErrors === 0;
+      } catch {
+        // Failed to parse, assume errors
+        return false;
+      }
+    }
+
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Lint check failed', errorObj, { filePath });
+    return false;
+  }
+}
+
+/**
+ * Run custom validation command
+ */
+async function runCustomValidation(command: string): Promise<boolean> {
+  logDebug('Running custom validation', { command });
+
+  try {
+    await execAsync(command, {
+      timeout: 60000, // 60 second timeout
+    });
+
+    logDebug('Custom validation passed', { command });
+    return true;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Custom validation failed', errorObj, { command });
+    return false;
+  }
+}
+
+/**
+ * Generate default acceptance criteria for a task
+ */
+export function generateDefaultCriteria(task: Task): AcceptanceCriterion[] {
+  const criteria: AcceptanceCriterion[] = [];
+
+  // If task plan exists, generate criteria based on files
+  if (task.plan) {
+    // Check that all created files exist
+    const createSteps = task.plan.steps.filter(s => s.mode === 'create');
+    for (const step of createSteps) {
+      criteria.push({
+        description: `File ${step.target_file} exists`,
+        type: 'file_exists',
+        check: step.target_file,
+        met: false,
+      });
+
+      // If it's a test file, add a test_passes criterion
+      if (step.target_file.includes('.test.')) {
+        criteria.push({
+          description: `Tests in ${step.target_file} pass`,
+          type: 'test_passes',
+          check: step.target_file,
+          met: false,
+        });
+      }
+    }
+
+    // Add lint check for all touched files
+    const allFiles = new Set([
+      ...createSteps.map(s => s.target_file),
+      ...task.plan.steps.filter(s => s.mode !== 'create').map(s => s.target_file),
+    ]);
+
+    for (const file of allFiles) {
+      // Only check non-test files for lint
+      if (!file.includes('.test.')) {
+        criteria.push({
+          description: `No lint errors in ${file}`,
+          type: 'no_lint_errors',
+          check: file,
+          met: false,
+        });
+      }
+    }
+  }
+
+  return criteria;
+}
+
+/**
+ * Check if task can be marked as completed
+ */
+export function canCompleteTask(task: Task): boolean {
+  // All steps must be completed
+  if (task.steps_completed < task.steps_total) {
+    return false;
+  }
+
+  // All acceptance criteria must be met
+  if (task.acceptance_criteria.length > 0) {
+    return task.acceptance_criteria.every(c => c.met);
+  }
+
+  // If no criteria defined, task is complete when all steps done
+  return true;
+}

package/src/task/agent-coordinator.ts

@@ -0,0 +1,220 @@
+/**
+ * Task Agent Coordinator
+ *
+ * Coordinates multi-agent execution of task steps using the mycelium
+ * process spawning system (Phase 3) for true RALPH-style parallelization.
+ *
+ * This replaces the simple Promise.all() approach with real agent processes
+ * that use file locks, inhibitors, and the full executeAgent() cycle.
+ */
+
+import { fork, ChildProcess } from 'child_process';
+import { Task, TaskStep, Mode } from '../types/index.js';
+import { logDebug, logError, logInfo } from '../utils/logger.js';
+import { randomUUID } from 'crypto';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export interface StepAssignment {
+  stepOrder: number;
+  targetFile: string;
+  mode: Mode;
+  description: string;
+  taskId: string;
+}
+
+export interface AgentResult {
+  stepOrder: number;
+  success: boolean;
+  traceId?: string;
+  error?: string;
+  exitCode: number | null;
+}
+
+/**
+ * Spawn an agent for a specific task step
+ * Each agent runs as an independent process via child_process.fork()
+ */
+export function spawnAgentForStep(
+  task: Task,
+  step: TaskStep
+): Promise<AgentResult> {
+  return new Promise((resolve) => {
+    const agentId = `agent-${randomUUID().substring(0, 8)}`;
+
+    logDebug('Spawning agent for task step', {
+      agentId,
+      taskId: task.id,
+      stepOrder: step.order,
+      targetFile: step.target_file,
+      mode: step.mode,
+    });
+
+    // Path to the compiled task worker file
+    const workerPath = path.join(__dirname, '../agent/task-worker.js');
+
+    // Spawn agent process with task context
+    const child = fork(workerPath, [], {
+      env: {
+        ...process.env,
+        AGENT_ID: agentId,
+        TASK_ID: task.id,
+        STEP_ORDER: String(step.order),
+        TARGET_FILE: step.target_file,
+        MODE: step.mode,
+        STEP_DESCRIPTION: step.description,
+      },
+      stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+    });
+
+    let result: AgentResult = {
+      stepOrder: step.order,
+      success: false,
+      exitCode: null,
+    };
+
+    // Set timeout (5 minutes)
+    const timeout = setTimeout(() => {
+      logError('Agent timeout', new Error('Agent timed out'), {
+        agentId,
+        stepOrder: step.order,
+      });
+      child.kill('SIGTERM');
+      result.error = 'Agent timed out after 5 minutes';
+      result.exitCode = -1;
+      resolve(result);
+    }, 300_000);
+
+    // Handle IPC messages from agent
+    child.on('message', (message: any) => {
+      if (message.type === 'result') {
+        logDebug('Agent result received', {
+          agentId,
+          stepOrder: step.order,
+          success: message.success,
+        });
+
+        result = {
+          stepOrder: step.order,
+          success: message.success,
+          traceId: message.traceId,
+          error: message.error,
+          exitCode: 0,
+        };
+      } else if (message.type === 'progress') {
+        logInfo('Agent progress', {
+          agentId,
+          stepOrder: step.order,
+          message: message.message,
+        });
+      }
+    });
+
+    // Handle agent exit
+    child.on('exit', (code, signal) => {
+      clearTimeout(timeout);
+
+      result.exitCode = code;
+
+      logInfo('Agent exited', {
+        agentId,
+        stepOrder: step.order,
+        code,
+        signal,
+        success: result.success,
+      });
+
+      // If we didn't receive a result message, mark as failure
+      if (!result.success && !result.error) {
+        result.error = `Agent exited with code ${code}`;
+      }
+
+      resolve(result);
+    });
+
+    // Handle errors
+    child.on('error', (error) => {
+      clearTimeout(timeout);
+      logError('Agent error', error, {
+        agentId,
+        stepOrder: step.order,
+      });
+
+      result.error = error.message;
+      result.exitCode = -1;
+      resolve(result);
+    });
+
+    // Forward stderr for debugging
+    if (child.stderr) {
+      child.stderr.on('data', (data) => {
+        logDebug('Agent stderr', {
+          agentId,
+          stepOrder: step.order,
+          output: data.toString(),
+        });
+      });
+    }
+  });
+}
+
+/**
+ * Execute a wave of task steps in parallel using agent processes
+ * This is the true mycelium multi-agent coordination
+ */
+export async function executeWaveWithAgents(
+  task: Task,
+  wave: TaskStep[]
+): Promise<AgentResult[]> {
+  logInfo('Executing wave with agent processes', {
+    taskId: task.id,
+    waveSize: wave.length,
+    steps: wave.map(s => s.order),
+  });
+
+  // Spawn all agents in parallel
+  const agentPromises = wave.map(step => spawnAgentForStep(task, step));
+
+  // Wait for all agents to complete
+  const results = await Promise.all(agentPromises);
+
+  logInfo('Wave execution complete', {
+    taskId: task.id,
+    total: results.length,
+    successful: results.filter(r => r.success).length,
+    failed: results.filter(r => !r.success).length,
+  });
+
+  return results;
+}
+
+/**
+ * Get parallelizable steps grouped by dependency waves
+ * Same logic as before, but now we spawn agents for each wave
+ */
+export function getParallelizableSteps(steps: TaskStep[]): TaskStep[][] {
+  const waves: TaskStep[][] = [];
+  const completed = new Set<number>();
+
+  while (completed.size < steps.length) {
+    // Find steps whose dependencies are all completed
+    const ready = steps.filter(
+      step =>
+        !completed.has(step.order) &&
+        step.depends_on.every(dep => completed.has(dep))
+    );
+
+    if (ready.length === 0) {
+      throw new Error('Circular dependency detected in task steps');
+    }
+
+    waves.push(ready);
+    ready.forEach(step => completed.add(step.order));
+  }
+
+  return waves;
+}