popeye-cli 1.0.0

package/src/workflow/execution-mode.ts

@@ -0,0 +1,517 @@
+/**
+ * Execution Mode workflow
+ * Handles task execution, testing, and error recovery
+ */
+
+import type { ProjectState, Task, Milestone } from '../types/workflow.js';
+import { generateCode, type ClaudeExecuteResult } from '../adapters/claude.js';
+import {
+  loadProject,
+  updateState,
+  updateTaskStatus,
+  setCurrentMilestone,
+  setCurrentTask,
+  getNextTask,
+  getProgress,
+  completeProject,
+  failProject,
+} from '../state/index.js';
+import {
+  runTests,
+  testsExist,
+  getTestSummary,
+  type TestResult,
+} from './test-runner.js';
+
+/**
+ * Options for execution mode
+ */
+export interface ExecutionModeOptions {
+  projectDir: string;
+  maxRetries?: number;
+  onProgress?: (phase: string, message: string) => void;
+  onTaskStart?: (milestone: Milestone, task: Task) => void;
+  onTaskComplete?: (milestone: Milestone, task: Task, success: boolean) => void;
+  onTestResult?: (result: TestResult) => void;
+}
+
+/**
+ * Result of task execution
+ */
+export interface TaskExecutionResult {
+  success: boolean;
+  task: Task;
+  response?: string;
+  testResult?: TestResult;
+  error?: string;
+  retries: number;
+}
+
+/**
+ * Result of execution mode
+ */
+export interface ExecutionModeResult {
+  success: boolean;
+  state: ProjectState;
+  completedTasks: number;
+  failedTasks: number;
+  error?: string;
+}
+
+/**
+ * Maximum number of retries for failed tests
+ */
+const DEFAULT_MAX_RETRIES = 3;
+
+/**
+ * Build the execution context for a task
+ *
+ * @param state - Current project state
+ * @param milestone - Current milestone
+ * @param task - Current task
+ * @returns Context string for code generation
+ */
+function buildTaskContext(
+  state: ProjectState,
+  milestone: Milestone,
+  _task: Task
+): string {
+  const lines: string[] = [];
+
+  lines.push(`## Project: ${state.name}`);
+  lines.push(`Language: ${state.language}`);
+  lines.push('');
+
+  if (state.specification) {
+    lines.push('## Specification');
+    lines.push(state.specification.slice(0, 2000));
+    lines.push('');
+  }
+
+  if (state.plan) {
+    lines.push('## Development Plan');
+    lines.push(state.plan.slice(0, 2000));
+    lines.push('');
+  }
+
+  lines.push('## Current Milestone');
+  lines.push(`Name: ${milestone.name}`);
+  lines.push(`Description: ${milestone.description}`);
+  lines.push('');
+
+  // Add completed tasks for context
+  const completedTasks = milestone.tasks.filter((t) => t.status === 'complete');
+  if (completedTasks.length > 0) {
+    lines.push('## Completed Tasks in This Milestone');
+    for (const t of completedTasks) {
+      lines.push(`- ${t.name}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Execute a single task
+ *
+ * @param task - The task to execute
+ * @param context - Execution context
+ * @param projectDir - Project directory
+ * @returns Execution result
+ */
+export async function executeTask(
+  task: Task,
+  context: string,
+  projectDir: string
+): Promise<ClaudeExecuteResult> {
+  const prompt = `
+## Task
+${task.name}
+
+## Description
+${task.description || task.name}
+
+${task.testPlan ? `## Test Requirements\n${task.testPlan}\n` : ''}
+
+Please implement this task completely. After implementing:
+1. Create appropriate tests if needed
+2. Ensure code follows best practices
+3. Document any complex logic
+`.trim();
+
+  return generateCode(prompt, context, { cwd: projectDir });
+}
+
+/**
+ * Handle a test failure by attempting to fix the code
+ *
+ * @param task - The failed task
+ * @param testResult - The test result
+ * @param context - Execution context
+ * @param projectDir - Project directory
+ * @returns Fix attempt result
+ */
+export async function handleTestFailure(
+  task: Task,
+  testResult: TestResult,
+  context: string,
+  projectDir: string
+): Promise<ClaudeExecuteResult> {
+  const prompt = `
+## Test Failure Fix Required
+
+The tests for the following task have failed:
+
+### Task
+${task.name}
+
+### Test Output
+\`\`\`
+${testResult.output.slice(0, 3000)}
+\`\`\`
+
+### Failed Tests
+${testResult.failedTests?.map((t) => `- ${t}`).join('\n') || 'See output above'}
+
+Please:
+1. Analyze the test failures
+2. Fix the code to make all tests pass
+3. Do NOT modify the tests unless they are incorrect
+`.trim();
+
+  return generateCode(prompt, context, { cwd: projectDir });
+}
+
+/**
+ * Execute a task with retry logic for test failures
+ *
+ * @param milestone - The milestone containing the task
+ * @param task - The task to execute
+ * @param state - Current project state
+ * @param options - Execution options
+ * @returns Task execution result
+ */
+async function executeTaskWithRetry(
+  milestone: Milestone,
+  task: Task,
+  state: ProjectState,
+  options: ExecutionModeOptions
+): Promise<TaskExecutionResult> {
+  const {
+    projectDir,
+    maxRetries = DEFAULT_MAX_RETRIES,
+    onTestResult,
+  } = options;
+
+  const context = buildTaskContext(state, milestone, task);
+  let retries = 0;
+
+  // Execute the task
+  const execResult = await executeTask(task, context, projectDir);
+
+  if (!execResult.success) {
+    return {
+      success: false,
+      task,
+      error: execResult.error || 'Task execution failed',
+      retries: 0,
+    };
+  }
+
+  // Check if tests exist
+  const hasTests = await testsExist(projectDir, state.language);
+
+  if (!hasTests) {
+    // No tests to run, mark as complete
+    return {
+      success: true,
+      task,
+      response: execResult.response,
+      retries: 0,
+    };
+  }
+
+  // Run tests with retry loop
+  while (retries <= maxRetries) {
+    const testResult = await runTests(projectDir, state.language);
+
+    if (onTestResult) {
+      onTestResult(testResult);
+    }
+
+    if (testResult.success) {
+      return {
+        success: true,
+        task,
+        response: execResult.response,
+        testResult,
+        retries,
+      };
+    }
+
+    // Tests failed
+    if (retries >= maxRetries) {
+      return {
+        success: false,
+        task,
+        response: execResult.response,
+        testResult,
+        error: `Tests failed after ${retries} retries: ${getTestSummary(testResult)}`,
+        retries,
+      };
+    }
+
+    // Attempt to fix
+    retries++;
+    const fixResult = await handleTestFailure(task, testResult, context, projectDir);
+
+    if (!fixResult.success) {
+      return {
+        success: false,
+        task,
+        testResult,
+        error: `Fix attempt failed: ${fixResult.error}`,
+        retries,
+      };
+    }
+  }
+
+  // Should not reach here
+  return {
+    success: false,
+    task,
+    error: 'Unexpected error in retry loop',
+    retries,
+  };
+}
+
+/**
+ * Run execution mode for a project
+ *
+ * @param options - Execution options
+ * @returns Execution mode result
+ */
+export async function runExecutionMode(
+  options: ExecutionModeOptions
+): Promise<ExecutionModeResult> {
+  const {
+    projectDir,
+    onProgress,
+    onTaskStart,
+    onTaskComplete,
+  } = options;
+
+  let completedTasks = 0;
+  let failedTasks = 0;
+
+  try {
+    let state = await loadProject(projectDir);
+
+    // Ensure we're in execution phase
+    if (state.phase !== 'execution') {
+      return {
+        success: false,
+        state,
+        completedTasks: 0,
+        failedTasks: 0,
+        error: `Cannot run execution mode: project is in ${state.phase} phase`,
+      };
+    }
+
+    // Update status
+    state = await updateState(projectDir, { status: 'in-progress' });
+
+    onProgress?.('execution-start', 'Starting execution mode...');
+
+    // Process tasks
+    let nextTask = await getNextTask(projectDir);
+
+    while (nextTask) {
+      const { milestone, task } = nextTask;
+
+      // Set current milestone and task
+      state = await setCurrentMilestone(projectDir, milestone.id);
+      state = await setCurrentTask(projectDir, task.id);
+
+      // Update task to in-progress
+      state = await updateTaskStatus(projectDir, task.id, 'in-progress');
+
+      onProgress?.(
+        'task-start',
+        `Executing: ${task.name} (Milestone: ${milestone.name})`
+      );
+
+      if (onTaskStart) {
+        onTaskStart(milestone, task);
+      }
+
+      // Execute the task
+      const result = await executeTaskWithRetry(
+        milestone,
+        task,
+        state,
+        options
+      );
+
+      if (result.success) {
+        state = await updateTaskStatus(projectDir, task.id, 'complete', {
+          testsPassed: result.testResult?.success,
+        });
+        completedTasks++;
+
+        onProgress?.(
+          'task-complete',
+          `Completed: ${task.name}${result.testResult ? ` (${getTestSummary(result.testResult)})` : ''}`
+        );
+      } else {
+        state = await updateTaskStatus(projectDir, task.id, 'failed', {
+          testsPassed: false,
+          error: result.error,
+        });
+        failedTasks++;
+
+        onProgress?.(
+          'task-failed',
+          `Failed: ${task.name} - ${result.error}`
+        );
+      }
+
+      if (onTaskComplete) {
+        onTaskComplete(milestone, task, result.success);
+      }
+
+      // Get next task
+      nextTask = await getNextTask(projectDir);
+    }
+
+    // Check final status
+    const progress = await getProgress(projectDir);
+
+    if (failedTasks > 0) {
+      state = await failProject(
+        projectDir,
+        `${failedTasks} tasks failed out of ${progress.totalTasks}`
+      );
+
+      return {
+        success: false,
+        state,
+        completedTasks,
+        failedTasks,
+        error: `Execution completed with ${failedTasks} failed tasks`,
+      };
+    }
+
+    // All tasks complete
+    state = await completeProject(projectDir);
+
+    onProgress?.(
+      'execution-complete',
+      `Project complete! ${completedTasks} tasks executed successfully.`
+    );
+
+    return {
+      success: true,
+      state,
+      completedTasks,
+      failedTasks: 0,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    onProgress?.('error', errorMessage);
+
+    return {
+      success: false,
+      state: await loadProject(projectDir).catch(() => ({} as ProjectState)),
+      completedTasks,
+      failedTasks,
+      error: errorMessage,
+    };
+  }
+}
+
+/**
+ * Resume execution mode from where it left off
+ *
+ * @param options - Execution options
+ * @returns Execution mode result
+ */
+export async function resumeExecutionMode(
+  options: ExecutionModeOptions
+): Promise<ExecutionModeResult> {
+  const state = await loadProject(options.projectDir);
+
+  // Check current status
+  if (state.status === 'complete') {
+    return {
+      success: true,
+      state,
+      completedTasks: state.milestones.flatMap((m) => m.tasks).filter((t) => t.status === 'complete').length,
+      failedTasks: 0,
+    };
+  }
+
+  // Reset failed tasks to pending so they can be retried
+  if (state.status === 'failed') {
+    const updatedMilestones = state.milestones.map((m) => ({
+      ...m,
+      tasks: m.tasks.map((t) =>
+        t.status === 'failed' ? { ...t, status: 'pending' as const, error: undefined } : t
+      ),
+    }));
+
+    await updateState(options.projectDir, {
+      milestones: updatedMilestones,
+      status: 'pending',
+      error: undefined,
+    });
+  }
+
+  return runExecutionMode(options);
+}
+
+/**
+ * Execute a single task by ID
+ *
+ * @param projectDir - Project directory
+ * @param taskId - Task ID to execute
+ * @param options - Execution options
+ * @returns Task execution result
+ */
+export async function executeSingleTask(
+  projectDir: string,
+  taskId: string,
+  options: Partial<ExecutionModeOptions> = {}
+): Promise<TaskExecutionResult> {
+  const state = await loadProject(projectDir);
+
+  // Find the task
+  let foundTask: Task | undefined;
+  let foundMilestone: Milestone | undefined;
+
+  for (const milestone of state.milestones) {
+    const task = milestone.tasks.find((t) => t.id === taskId);
+    if (task) {
+      foundTask = task;
+      foundMilestone = milestone;
+      break;
+    }
+  }
+
+  if (!foundTask || !foundMilestone) {
+    return {
+      success: false,
+      task: { id: taskId, name: 'Unknown', status: 'pending', description: '' },
+      error: `Task ${taskId} not found`,
+      retries: 0,
+    };
+  }
+
+  return executeTaskWithRetry(
+    foundMilestone,
+    foundTask,
+    state,
+    { projectDir, ...options }
+  );
+}