popeye-cli 1.0.0

package/src/workflow/index.ts

@@ -0,0 +1,396 @@
+/**
+ * Workflow orchestration module
+ * Main entry point for managing the complete project workflow
+ */
+
+import type { ProjectSpec } from '../types/project.js';
+import type { ProjectState, WorkflowPhase } from '../types/workflow.js';
+import type { ConsensusConfig } from '../types/consensus.js';
+import {
+  loadProject,
+  projectExists,
+  getProgress,
+  resetToPhase,
+  deleteProject,
+} from '../state/index.js';
+import {
+  runPlanMode,
+  resumePlanMode,
+  type PlanModeResult,
+} from './plan-mode.js';
+import {
+  runExecutionMode,
+  resumeExecutionMode,
+  executeSingleTask,
+  type ExecutionModeResult,
+  type TaskExecutionResult,
+} from './execution-mode.js';
+// Types are re-exported via export * from statements below
+
+// Re-export submodules
+export * from './consensus.js';
+export * from './plan-mode.js';
+export * from './execution-mode.js';
+export * from './test-runner.js';
+
+/**
+ * Workflow options
+ */
+export interface WorkflowOptions {
+  projectDir: string;
+  consensusConfig?: Partial<ConsensusConfig>;
+  maxRetries?: number;
+  onProgress?: (phase: string, message: string) => void;
+}
+
+/**
+ * Complete workflow result
+ */
+export interface WorkflowResult {
+  success: boolean;
+  state: ProjectState;
+  planResult?: PlanModeResult;
+  executionResult?: ExecutionModeResult;
+  error?: string;
+}
+
+/**
+ * Run the complete workflow from idea to deployed code
+ *
+ * @param spec - Project specification
+ * @param options - Workflow options
+ * @returns Workflow result
+ */
+export async function runWorkflow(
+  spec: ProjectSpec,
+  options: WorkflowOptions
+): Promise<WorkflowResult> {
+  const { projectDir, consensusConfig, maxRetries, onProgress } = options;
+
+  try {
+    // Phase 1: Plan Mode
+    onProgress?.('workflow', 'Starting Plan Mode...');
+
+    const planResult = await runPlanMode(spec, {
+      projectDir,
+      consensusConfig,
+      onProgress,
+    });
+
+    if (!planResult.success) {
+      return {
+        success: false,
+        state: planResult.state,
+        planResult,
+        error: planResult.error || 'Plan mode failed to reach consensus',
+      };
+    }
+
+    // Phase 2: Execution Mode
+    onProgress?.('workflow', 'Starting Execution Mode...');
+
+    const executionResult = await runExecutionMode({
+      projectDir,
+      maxRetries,
+      onProgress,
+    });
+
+    return {
+      success: executionResult.success,
+      state: executionResult.state,
+      planResult,
+      executionResult,
+      error: executionResult.error,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+    return {
+      success: false,
+      state: await loadProject(projectDir).catch(() => ({} as ProjectState)),
+      error: errorMessage,
+    };
+  }
+}
+
+/**
+ * Resume an existing workflow from where it left off
+ *
+ * @param projectDir - Project directory
+ * @param options - Workflow options
+ * @returns Workflow result
+ */
+export async function resumeWorkflow(
+  projectDir: string,
+  options: Omit<WorkflowOptions, 'projectDir'>
+): Promise<WorkflowResult> {
+  const { consensusConfig, maxRetries, onProgress } = options;
+
+  try {
+    // Check if project exists
+    if (!(await projectExists(projectDir))) {
+      throw new Error(`No project found at ${projectDir}`);
+    }
+
+    const state = await loadProject(projectDir);
+
+    // Determine which phase to resume
+    switch (state.phase) {
+      case 'plan': {
+        onProgress?.('workflow', 'Resuming Plan Mode...');
+
+        const planResult = await resumePlanMode(projectDir, {
+          consensusConfig,
+          onProgress,
+        });
+
+        if (!planResult.success) {
+          return {
+            success: false,
+            state: planResult.state,
+            planResult,
+            error: planResult.error || 'Plan mode failed to reach consensus',
+          };
+        }
+
+        // Continue to execution
+        onProgress?.('workflow', 'Starting Execution Mode...');
+
+        const executionResult = await runExecutionMode({
+          projectDir,
+          maxRetries,
+          onProgress,
+        });
+
+        return {
+          success: executionResult.success,
+          state: executionResult.state,
+          planResult,
+          executionResult,
+          error: executionResult.error,
+        };
+      }
+
+      case 'execution': {
+        onProgress?.('workflow', 'Resuming Execution Mode...');
+
+        const executionResult = await resumeExecutionMode({
+          projectDir,
+          maxRetries,
+          onProgress,
+        });
+
+        return {
+          success: executionResult.success,
+          state: executionResult.state,
+          executionResult,
+          error: executionResult.error,
+        };
+      }
+
+      case 'complete': {
+        onProgress?.('workflow', 'Project already complete');
+        return {
+          success: true,
+          state,
+        };
+      }
+
+      default:
+        throw new Error(`Unknown phase: ${state.phase}`);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+    return {
+      success: false,
+      state: await loadProject(projectDir).catch(() => ({} as ProjectState)),
+      error: errorMessage,
+    };
+  }
+}
+
+/**
+ * Get workflow status and progress
+ *
+ * @param projectDir - Project directory
+ * @returns Status information
+ */
+export async function getWorkflowStatus(projectDir: string): Promise<{
+  exists: boolean;
+  state?: ProjectState;
+  progress?: {
+    totalMilestones: number;
+    completedMilestones: number;
+    totalTasks: number;
+    completedTasks: number;
+    percentComplete: number;
+  };
+}> {
+  if (!(await projectExists(projectDir))) {
+    return { exists: false };
+  }
+
+  const state = await loadProject(projectDir);
+  const progress = await getProgress(projectDir);
+
+  return {
+    exists: true,
+    state,
+    progress,
+  };
+}
+
+/**
+ * Reset workflow to a specific phase
+ *
+ * @param projectDir - Project directory
+ * @param phase - Phase to reset to
+ * @returns Updated state
+ */
+export async function resetWorkflow(
+  projectDir: string,
+  phase: WorkflowPhase
+): Promise<ProjectState> {
+  return resetToPhase(projectDir, phase);
+}
+
+/**
+ * Cancel and delete a workflow
+ *
+ * @param projectDir - Project directory
+ * @returns True if deleted
+ */
+export async function cancelWorkflow(projectDir: string): Promise<boolean> {
+  return deleteProject(projectDir);
+}
+
+/**
+ * Get a human-readable summary of the workflow status
+ *
+ * @param projectDir - Project directory
+ * @returns Summary string
+ */
+export async function getWorkflowSummary(projectDir: string): Promise<string> {
+  const status = await getWorkflowStatus(projectDir);
+
+  if (!status.exists || !status.state) {
+    return 'No project found';
+  }
+
+  const { state, progress } = status;
+  const lines: string[] = [];
+
+  lines.push(`# Project: ${state.name}`);
+  lines.push('');
+  lines.push(`**Phase:** ${state.phase}`);
+  lines.push(`**Status:** ${state.status}`);
+  lines.push(`**Language:** ${state.language}`);
+  lines.push('');
+
+  if (progress) {
+    lines.push(`## Progress`);
+    lines.push(`- Milestones: ${progress.completedMilestones}/${progress.totalMilestones}`);
+    lines.push(`- Tasks: ${progress.completedTasks}/${progress.totalTasks}`);
+    lines.push(`- Complete: ${progress.percentComplete}%`);
+    lines.push('');
+  }
+
+  if (state.consensusHistory && state.consensusHistory.length > 0) {
+    const lastConsensus = state.consensusHistory[state.consensusHistory.length - 1];
+    lines.push(`## Last Consensus`);
+    lines.push(`- Score: ${lastConsensus.result.score}%`);
+    lines.push(`- Iteration: ${lastConsensus.iteration}`);
+    lines.push('');
+  }
+
+  if (state.error) {
+    lines.push(`## Error`);
+    lines.push(state.error);
+    lines.push('');
+  }
+
+  if (state.currentMilestone) {
+    const milestone = state.milestones.find((m) => m.id === state.currentMilestone);
+    if (milestone) {
+      lines.push(`## Current Milestone`);
+      lines.push(`**${milestone.name}**`);
+
+      if (state.currentTask) {
+        const task = milestone.tasks.find((t) => t.id === state.currentTask);
+        if (task) {
+          lines.push(`- Current Task: ${task.name}`);
+        }
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Execute a single task manually
+ *
+ * @param projectDir - Project directory
+ * @param taskId - Task ID
+ * @param options - Execution options
+ * @returns Task result
+ */
+export async function executeTask(
+  projectDir: string,
+  taskId: string,
+  options?: { maxRetries?: number; onProgress?: (message: string) => void }
+): Promise<TaskExecutionResult> {
+  return executeSingleTask(projectDir, taskId, {
+    projectDir,
+    maxRetries: options?.maxRetries,
+    onProgress: options?.onProgress ? (_, msg) => options.onProgress!(msg) : undefined,
+  });
+}
+
+/**
+ * Validate that a project is ready for execution
+ *
+ * @param projectDir - Project directory
+ * @returns Validation result
+ */
+export async function validateReadyForExecution(projectDir: string): Promise<{
+  ready: boolean;
+  issues: string[];
+}> {
+  const issues: string[] = [];
+
+  if (!(await projectExists(projectDir))) {
+    return { ready: false, issues: ['No project found'] };
+  }
+
+  const state = await loadProject(projectDir);
+
+  if (!state.plan) {
+    issues.push('No approved plan');
+  }
+
+  if (state.milestones.length === 0) {
+    issues.push('No milestones defined');
+  }
+
+  const allTasks = state.milestones.flatMap((m) => m.tasks);
+  if (allTasks.length === 0) {
+    issues.push('No tasks defined');
+  }
+
+  if (state.phase === 'plan' && state.consensusHistory.length === 0) {
+    issues.push('Plan has not been through consensus review');
+  }
+
+  const lastConsensus = state.consensusHistory[state.consensusHistory.length - 1];
+  if (lastConsensus && lastConsensus.result.score < 95) {
+    issues.push(`Consensus score (${lastConsensus.result.score}%) below 95% threshold`);
+  }
+
+  return {
+    ready: issues.length === 0,
+    issues,
+  };
+}