claude-mycelium 2.0.0 → 2.2.0

package/src/task/executor.ts

@@ -0,0 +1,543 @@
+/**
+ * Task Execution Implementation
+ * Per second-spec §12.2: Task Step Execution
+ *
+ * Executes task steps using the mycelium multi-agent system.
+ * Each step spawns an independent agent process that uses file locks,
+ * inhibitors, and the full RALPH-style executeAgent() cycle.
+ *
+ * This is TRUE multi-agent coordination as per ADR-004.
+ */
+
+import { Task, TaskStep } from '../types/index.js';
+import { logDebug, logError, logInfo } from '../utils/logger.js';
+import {
+  executeWaveWithAgents,
+  getParallelizableSteps,
+  type AgentResult,
+} from './agent-coordinator.js';
+
+/**
+ * Execute a complete task by running all steps in dependency order
+ *
+ * This spawns independent agent processes for each step, coordinated
+ * via file locks. Multiple agents can work in parallel on different
+ * files, implementing true RALPH-style multi-agent coordination.
+ */
+export async function executeTask(task: Task): Promise<Task> {
+  logInfo('Executing task with multi-agent coordination', {
+    taskId: task.id,
+    steps: task.plan?.steps.length,
+  });
+
+  if (!task.plan) {
+    throw new Error('Cannot execute task without a plan');
+  }
+
+  const waves = getParallelizableSteps(task.plan.steps);
+
+  logInfo('Task execution plan', {
+    taskId: task.id,
+    totalSteps: task.plan.steps.length,
+    waves: waves.length,
+    waveSizes: waves.map(w => w.length),
+  });
+
+  for (let waveIndex = 0; waveIndex < waves.length; waveIndex++) {
+    const wave = waves[waveIndex];
+    logInfo('Executing wave', {
+      taskId: task.id,
+      wave: waveIndex + 1,
+      totalWaves: waves.length,
+      stepsInWave: wave.length,
+    });
+
+    // Execute all steps in this wave using agent processes
+    // Each agent runs in its own process with file locks
+    const results: AgentResult[] = await executeWaveWithAgents(task, wave);
+
+    // Check for failures
+    const failed = results.find(r => !r.success);
+    if (failed) {
+      task.status = 'failed';
+      task.error = failed.error || 'Agent execution failed';
+      logError('Task wave failed', new Error(task.error), {
+        taskId: task.id,
+        wave: waveIndex + 1,
+        failedStep: failed.stepOrder,
+      });
+      return task;
+    }
+
+    // Update completed steps
+    for (let i = 0; i < wave.length; i++) {
+      const result = results.find(r => r.stepOrder === wave[i].order);
+      if (result && result.success) {
+        wave[i].completed = true;
+        wave[i].trace_id = result.traceId;
+        task.steps_completed++;
+
+        // Track file changes
+        if (wave[i].mode === 'create') {
+          task.files_created.push(wave[i].target_file);
+        } else {
+          if (!task.files_modified.includes(wave[i].target_file)) {
+            task.files_modified.push(wave[i].target_file);
+          }
+        }
+
+        if (result.traceId) {
+          task.traces.push(result.traceId);
+        }
+      }
+    }
+
+    logInfo('Wave complete', {
+      taskId: task.id,
+      wave: waveIndex + 1,
+      successCount: results.filter(r => r.success).length,
+      failureCount: results.filter(r => !r.success).length,
+    });
+  }
+
+  task.status = 'completed';
+  logInfo('Task execution completed', {
+    taskId: task.id,
+    stepsCompleted: task.steps_completed,
+    filesCreated: task.files_created.length,
+    filesModified: task.files_modified.length,
+  });
+
+  return task;
+}
+
+
+/**
+ * Track progress of task execution
+ */
+export function trackProgress(task: Task): {
+  percentage: number;
+  completed: number;
+  total: number;
+  status: string;
+} {
+  const percentage = task.steps_total > 0
+    ? Math.round((task.steps_completed / task.steps_total) * 100)
+    : 0;
+
+  return {
+    percentage,
+    completed: task.steps_completed,
+    total: task.steps_total,
+    status: task.status,
+  };
+}
+
+  task: Task,
+  step: TaskStep
+): Promise<{ success: boolean; trace_id?: string; error?: string }> {
+  // Check if file already exists
+  if (fileExists(step.target_file)) {
+    return {
+      success: false,
+      error: `Cannot create file ${step.target_file} - already exists`,
+    };
+  }
+
+  // Build prompt for file creation
+  const systemPrompt = buildCreateSystemPrompt();
+  const userPrompt = buildCreateUserPrompt(task, step);
+
+  // Call LLM to generate file content
+  const response = await callLLM({
+    prompt: userPrompt,
+    systemPrompt,
+    temperature: 0.5,
+    maxTokens: 4000,
+  });
+
+  // Extract code from response
+  const fileContent = extractCodeFromResponse(response.content);
+  if (!fileContent) {
+    return {
+      success: false,
+      error: 'Failed to extract code from LLM response',
+    };
+  }
+
+  // Write the file
+  writeFile(step.target_file, fileContent);
+
+  // Run CI to validate
+  const ciResult = await ciProvider.run({
+    additions: fileContent.split('\n').length,
+    deletions: 0,
+    files_touched: [step.target_file],
+  });
+
+  if (!ciResult.passed) {
+    // Revert - delete the file
+    try {
+      const fs = await import('fs');
+      fs.unlinkSync(step.target_file);
+    } catch {}
+    return {
+      success: false,
+      error: `CI failed: ${ciResult.output}`,
+    };
+  }
+
+  // Record trace
+  const traceId = await recordCreateTrace(
+    step.target_file,
+    fileContent,
+    response.usage,
+    response.model,
+    task.id
+  );
+
+  logDebug('Create step completed', {
+    file: step.target_file,
+    lines: fileContent.split('\n').length,
+    traceId,
+  });
+
+  return { success: true, trace_id: traceId };
+}
+
+/**
+ * Execute a modify mode step (existing file)
+ */
+async function executeModifyStep(
+  task: Task,
+  step: TaskStep
+): Promise<{ success: boolean; trace_id?: string; error?: string }> {
+  if (!fileExists(step.target_file)) {
+    return {
+      success: false,
+      error: `Cannot modify file ${step.target_file} - does not exist`,
+    };
+  }
+
+  const originalContent = readFile(step.target_file);
+  const gradientBefore = await calculateGradient(step.target_file);
+
+  // Build prompt for modification
+  const systemPrompt = buildModifySystemPrompt(step.mode as Mode);
+  const userPrompt = buildModifyUserPrompt(task, step, originalContent);
+
+  // Call LLM to generate changes
+  const response = await callLLM({
+    prompt: userPrompt,
+    systemPrompt,
+    temperature: 0.5,
+    maxTokens: 4000,
+  });
+
+  // Extract modified content
+  const modifiedContent = extractCodeFromResponse(response.content);
+  if (!modifiedContent) {
+    return {
+      success: false,
+      error: 'Failed to extract modified code from LLM response',
+    };
+  }
+
+  // Apply changes
+  writeFile(step.target_file, modifiedContent);
+
+  // Calculate change stats
+  const changeSet = calculateChanges(originalContent, modifiedContent, step.target_file);
+
+  // Run CI
+  const ciResult = await ciProvider.run(changeSet);
+  if (!ciResult.passed) {
+    // Revert changes
+    writeFile(step.target_file, originalContent);
+    return {
+      success: false,
+      error: `CI failed: ${ciResult.output}`,
+    };
+  }
+
+  // Calculate metrics after
+  const gradientAfter = await calculateGradient(step.target_file);
+
+  // Record trace
+  const traceId = await recordModifyTrace(
+    step.target_file,
+    step.mode as Mode,
+    gradientBefore,
+    gradientAfter,
+    changeSet,
+    response.usage,
+    response.model,
+    task.id
+  );
+
+  logDebug('Modify step completed', {
+    file: step.target_file,
+    mode: step.mode,
+    gradientDelta: gradientBefore.score - gradientAfter.score,
+    traceId,
+  });
+
+  return { success: true, trace_id: traceId };
+}
+
+/**
+ * Helper to calculate file metrics (not used in current implementation)
+ */
+/*
+async function calculateFileMetrics(filePath: string, allFiles: string[]): Promise<FileMetrics> {
+  const [complexity, churn, errorRate, debt, centrality] = await Promise.all([
+    calculateComplexity(filePath),
+    calculateChurn(filePath),
+    calculateErrorRate(filePath),
+    calculateDebt(filePath),
+    calculateCentrality(filePath),
+  ]);
+
+  return {
+    path: filePath,
+    complexity: complexity.normalized,
+    churn: churn.normalized,
+    error_rate: errorRate.normalized,
+    debt: debt.normalized,
+    centrality: centrality.normalized,
+    loc: getLineCount(filePath),
+  };
+}
+*/
+
+/**
+ * Get steps grouped by waves (parallelizable groups)
+ */
+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;
+}
+
+/**
+ * Build system prompt for create mode
+ */
+function buildCreateSystemPrompt(): string {
+  return `You are creating a new file as part of a larger task.
+
+Output the complete file content wrapped in triple backticks with the language identifier.
+
+Example:
+\`\`\`typescript
+// File content here
+\`\`\`
+
+Requirements:
+- Include all necessary imports
+- Add appropriate error handling
+- Include JSDoc comments for exported functions
+- Follow TypeScript best practices`;
+}
+
+/**
+ * Build user prompt for create mode
+ */
+function buildCreateUserPrompt(task: Task, step: TaskStep): string {
+  return `## Overall Task
+${task.description}
+
+## This Step
+${step.description}
+
+## File to Create
+${step.target_file}
+
+## Requirements
+- Create a working implementation
+- Include basic error handling
+- Add type annotations
+- Follow existing project patterns
+
+Generate the complete file content.`;
+}
+
+/**
+ * Build system prompt for modify mode
+ */
+function buildModifySystemPrompt(mode: Mode): string {
+  const modeInstructions: Record<Mode, string> = {
+    error_reducer: 'Focus on fixing bugs and adding error handling. Do not refactor for style.',
+    complexity_reducer: 'Focus on simplifying code structure. Extract functions, reduce nesting.',
+    debt_payer: 'Focus on fixing lint issues and improving types. Do not change logic.',
+    stabilizer: 'Focus on adding tests and documentation. Do not change implementation.',
+    explorer: 'You may challenge assumptions and propose larger changes within constraints.',
+  };
+
+  return `You are modifying an existing file in ${mode} mode.
+
+${modeInstructions[mode]}
+
+Output the complete modified file content wrapped in triple backticks.`;
+}
+
+/**
+ * Build user prompt for modify mode
+ */
+function buildModifyUserPrompt(task: Task, step: TaskStep, currentContent: string): string {
+  return `## Overall Task
+${task.description}
+
+## This Step
+${step.description}
+
+## Current File Content
+\`\`\`typescript
+${currentContent}
+\`\`\`
+
+Modify the file according to the step description and mode constraints.
+Output the complete modified file.`;
+}
+
+/**
+ * Extract code from LLM response (handle markdown code blocks)
+ */
+function extractCodeFromResponse(content: string): string | null {
+  // Try to find code in triple backticks
+  const codeBlockMatch = content.match(/```(?:typescript|ts|javascript|js)?\n([\s\S]*?)\n```/);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1];
+  }
+
+  // If no code block found, check if entire content looks like code
+  if (content.includes('import') || content.includes('export') || content.includes('function')) {
+    return content.trim();
+  }
+
+  return null;
+}
+
+/**
+ * Calculate changes between original and modified content
+ */
+function calculateChanges(
+  original: string,
+  modified: string,
+  filePath: string
+): ChangeSet {
+  const originalLines = original.split('\n');
+  const modifiedLines = modified.split('\n');
+
+  // Simple diff: count added and removed lines
+  const additions = modifiedLines.length > originalLines.length
+    ? modifiedLines.length - originalLines.length
+    : 0;
+  const deletions = originalLines.length > modifiedLines.length
+    ? originalLines.length - modifiedLines.length
+    : 0;
+
+  return {
+    additions,
+    deletions,
+    files_touched: [filePath],
+  };
+}
+
+/**
+ * Record trace for create step
+ */
+async function recordCreateTrace(
+  filePath: string,
+  content: string,
+  usage: { inputTokens: number; outputTokens: number },
+  model: string,
+  taskId: string
+): Promise<string> {
+  const cost: CostRecord = {
+    tokens_in: usage.inputTokens,
+    tokens_out: usage.outputTokens,
+    model,
+    estimated_usd: calculateCost(model, usage.inputTokens, usage.outputTokens),
+  };
+
+  // For create mode, gradient goes from 0 to 0 (no improvement measured)
+  const trace = createTraceEvent({
+    filePath,
+    mode: 'debt_payer', // Create is treated as debt_payer for metrics
+    gradientBefore: 0,
+    gradientAfter: 0,
+    metabolicCost: cost.estimated_usd * 100, // Normalize
+    efficiency: 0,
+    ciPassed: true,
+    changes: {
+      additions: content.split('\n').length,
+      deletions: 0,
+      files_touched: [filePath],
+    },
+    costRecord: cost,
+    notes: ['File created as part of task'],
+    taskId,
+  });
+
+  await recordTraceEvent(trace);
+  return trace.id;
+}
+
+/**
+ * Record trace for modify step
+ */
+async function recordModifyTrace(
+  filePath: string,
+  mode: Mode,
+  gradientBefore: { score: number },
+  gradientAfter: { score: number },
+  changes: ChangeSet,
+  usage: { inputTokens: number; outputTokens: number },
+  model: string,
+  taskId: string
+): Promise<string> {
+  const cost: CostRecord = {
+    tokens_in: usage.inputTokens,
+    tokens_out: usage.outputTokens,
+    model,
+    estimated_usd: calculateCost(model, usage.inputTokens, usage.outputTokens),
+  };
+
+  const gradientDelta = gradientBefore.score - gradientAfter.score;
+  const metabolicCost = cost.estimated_usd * 100; // Normalize
+  const efficiency = metabolicCost > 0 ? gradientDelta / metabolicCost : 0;
+
+  const trace = createTraceEvent({
+    filePath,
+    mode,
+    gradientBefore: gradientBefore.score,
+    gradientAfter: gradientAfter.score,
+    metabolicCost,
+    efficiency,
+    ciPassed: true,
+    changes,
+    costRecord: cost,
+    notes: ['Modified as part of task'],
+    taskId,
+  });
+
+  await recordTraceEvent(trace);
+  return trace.id;
+}

package/src/task/index.ts

@@ -0,0 +1,38 @@
+/**
+ * Task System Module
+ * Phase 5: Task Planning & Execution
+ *
+ * Exports all task-related functionality for LLM-based task decomposition,
+ * execution tracking, and acceptance criteria validation.
+ */
+
+export {
+  planTask,
+  analyzeDependencies,
+  identifyRisks,
+} from './planner.js';
+
+export {
+  executeTask,
+  executeStep,
+  trackProgress,
+} from './executor.js';
+
+export {
+  validateAcceptance,
+  checkFileExists,
+  runTests,
+  generateDefaultCriteria,
+  canCompleteTask,
+} from './acceptance.js';
+
+export {
+  storeTask,
+  loadTask,
+  listTasks,
+  listActiveTasks,
+  deleteTask,
+  updateTaskStatus,
+  getTaskHistoryForFile,
+  getTaskStatistics,
+} from './storage.js';