popeye-cli 1.0.0 → 1.1.0

package/src/workflow/index.ts

@@ -12,6 +12,8 @@ import {
   getProgress,
   resetToPhase,
   deleteProject,
+  verifyProjectCompletion,
+  resetIncompleteProject,
 } from '../state/index.js';
 import {
   runPlanMode,
@@ -25,6 +27,7 @@ import {
   type ExecutionModeResult,
   type TaskExecutionResult,
 } from './execution-mode.js';
+import { getWorkflowLogger } from './workflow-logger.js';
 // Types are re-exported via export * from statements below
 
 // Re-export submodules
@@ -32,6 +35,12 @@ export * from './consensus.js';
 export * from './plan-mode.js';
 export * from './execution-mode.js';
 export * from './test-runner.js';
+export * from './workflow-logger.js';
+export * from './ui-setup.js';
+export * from './ui-designer.js';
+export * from './ui-verification.js';
+export * from './project-verification.js';
+export * from './auto-fix.js';
 
 /**
  * Workflow options
@@ -67,7 +76,16 @@ export async function runWorkflow(
 ): Promise<WorkflowResult> {
   const { projectDir, consensusConfig, maxRetries, onProgress } = options;
 
+  // Initialize workflow logger
+  const logger = getWorkflowLogger(projectDir);
+
   try {
+    await logger.stageStart('init', 'Starting complete workflow', {
+      projectName: spec.name,
+      idea: spec.idea.slice(0, 200),
+      language: spec.language,
+    });
+
     // Phase 1: Plan Mode
     onProgress?.('workflow', 'Starting Plan Mode...');
 
@@ -78,6 +96,7 @@ export async function runWorkflow(
     });
 
     if (!planResult.success) {
+      await logger.stageFailed('init', 'Workflow failed in Plan Mode', planResult.error || 'Plan mode failed');
       return {
         success: false,
         state: planResult.state,
@@ -95,6 +114,15 @@ export async function runWorkflow(
       onProgress,
     });
 
+    if (executionResult.success) {
+      await logger.stageComplete('completion', 'Complete workflow finished successfully', {
+        completedTasks: executionResult.completedTasks,
+        failedTasks: executionResult.failedTasks,
+      });
+    } else {
+      await logger.stageFailed('completion', 'Workflow failed in Execution Mode', executionResult.error || 'Execution failed');
+    }
+
     return {
       success: executionResult.success,
       state: executionResult.state,
@@ -105,6 +133,10 @@ export async function runWorkflow(
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error';
 
+    await logger.stageFailed('init', 'Workflow failed with exception', errorMessage, {
+      errorType: error instanceof Error ? error.constructor.name : typeof error,
+    });
+
     return {
       success: false,
       state: await loadProject(projectDir).catch(() => ({} as ProjectState)),
@@ -113,18 +145,28 @@ export async function runWorkflow(
   }
 }
 
+/**
+ * Resume workflow options with additional context
+ */
+export interface ResumeWorkflowOptions extends Omit<WorkflowOptions, 'projectDir'> {
+  additionalContext?: string;
+}
+
 /**
  * Resume an existing workflow from where it left off
  *
  * @param projectDir - Project directory
- * @param options - Workflow options
+ * @param options - Workflow options with optional additional context
  * @returns Workflow result
  */
 export async function resumeWorkflow(
   projectDir: string,
-  options: Omit<WorkflowOptions, 'projectDir'>
+  options: ResumeWorkflowOptions
 ): Promise<WorkflowResult> {
-  const { consensusConfig, maxRetries, onProgress } = options;
+  const { consensusConfig, maxRetries, onProgress, additionalContext } = options;
+
+  // Initialize workflow logger
+  const logger = getWorkflowLogger(projectDir);
 
   try {
     // Check if project exists
@@ -134,13 +176,24 @@ export async function resumeWorkflow(
 
     const state = await loadProject(projectDir);
 
+    await logger.info('init', 'workflow_resume', 'Resuming workflow', {
+      projectName: state.name,
+      currentPhase: state.phase,
+      currentStatus: state.status,
+      hasAdditionalContext: !!additionalContext,
+    });
+
     // Determine which phase to resume
     switch (state.phase) {
       case 'plan': {
         onProgress?.('workflow', 'Resuming Plan Mode...');
+        if (additionalContext) {
+          onProgress?.('workflow', `Additional guidance: ${additionalContext}`);
+        }
 
         const planResult = await resumePlanMode(projectDir, {
           consensusConfig,
+          additionalContext,
           onProgress,
         });
 
@@ -189,10 +242,46 @@ export async function resumeWorkflow(
       }
 
       case 'complete': {
-        onProgress?.('workflow', 'Project already complete');
+        // Verify actual completion - don't trust status alone
+        const verification = await verifyProjectCompletion(projectDir);
+
+        if (verification.isComplete) {
+          onProgress?.('workflow', 'Project is fully complete');
+          onProgress?.('workflow', verification.progress.progressSummary);
+          return {
+            success: true,
+            state,
+          };
+        }
+
+        // Status says complete but work is incomplete - allow resume
+        onProgress?.(
+          'workflow',
+          `Project status is 'complete' but work is incomplete: ${verification.reason}`
+        );
+        onProgress?.(
+          'workflow',
+          `Progress: ${verification.progress.progressSummary}`
+        );
+
+        // Reset project to correct state and continue execution
+        onProgress?.('workflow', 'Resetting project status to allow resuming...');
+        const resetState = await resetIncompleteProject(projectDir);
+
+        onProgress?.('workflow', `Resuming Execution Mode (${resetState.phase} phase)...`);
+
+        const executionResult = await resumeExecutionMode({
+          projectDir,
+          maxRetries,
+          consensusConfig,
+          onProgress,
+        });
+
         return {
-          success: true,
-          state,
+          success: executionResult.success,
+          state: executionResult.state,
+          executionResult,
+          error: executionResult.error,
         };
       }