popeye-cli 1.0.0

package/src/cli/commands/create.ts

@@ -0,0 +1,308 @@
+/**
+ * Create command
+ * One-shot project creation from an idea
+ */
+
+import { Command } from 'commander';
+import path from 'node:path';
+import { ProjectSpecSchema, type OutputLanguage, type OpenAIModel } from '../../types/project.js';
+import { requireAuth } from '../../auth/index.js';
+import { runWorkflow } from '../../workflow/index.js';
+import { generateProject, projectDirExists, cleanupProject } from '../../generators/index.js';
+import {
+  printHeader,
+  printSection,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  printKeyValue,
+  printConsensusResult,
+  startSpinner,
+  updateSpinner,
+  succeedSpinner,
+  failSpinner,
+  stopSpinner,
+} from '../output.js';
+
+/**
+ * Create the create command
+ */
+export function createCreateCommand(): Command {
+  const create = new Command('create')
+    .description('Create a new project from an idea')
+    .argument('<idea>', 'Project idea or description')
+    .option('-n, --name <name>', 'Project name')
+    .option(
+      '-l, --language <lang>',
+      'Output language (python, typescript)',
+      'python'
+    )
+    .option(
+      '-m, --model <model>',
+      'OpenAI model for consensus (gpt-4o, gpt-4o-mini, o1-preview)',
+      'gpt-4o'
+    )
+    .option(
+      '-o, --output <dir>',
+      'Output directory',
+      process.cwd()
+    )
+    .option(
+      '--threshold <percent>',
+      'Consensus threshold percentage',
+      '95'
+    )
+    .option(
+      '--max-iterations <count>',
+      'Maximum consensus iterations',
+      '5'
+    )
+    .option(
+      '--skip-scaffold',
+      'Skip initial project scaffolding'
+    )
+    .action(async (idea: string, options) => {
+      try {
+        // Validate inputs
+        const language = options.language as OutputLanguage;
+        if (!['python', 'typescript'].includes(language)) {
+          printError(`Invalid language: ${language}. Use 'python' or 'typescript'.`);
+          process.exit(1);
+        }
+
+        const model = options.model as OpenAIModel;
+        const validModels = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'];
+        if (!validModels.includes(model)) {
+          printError(`Invalid model: ${model}. Use one of: ${validModels.join(', ')}`);
+          process.exit(1);
+        }
+
+        // Generate project name from idea if not provided
+        const projectName = options.name || generateProjectName(idea);
+        const outputDir = path.resolve(options.output);
+        const projectDir = path.join(outputDir, projectName);
+        const threshold = parseInt(options.threshold, 10);
+        const maxIterations = parseInt(options.maxIterations, 10);
+
+        // Validate project spec
+        const specResult = ProjectSpecSchema.safeParse({
+          idea,
+          name: projectName,
+          language,
+          openaiModel: model,
+          outputDir,
+        });
+
+        if (!specResult.success) {
+          printError(`Invalid project specification: ${specResult.error.message}`);
+          process.exit(1);
+        }
+
+        const spec = specResult.data;
+
+        // Print header
+        printHeader('Popeye CLI - Project Creation');
+
+        printSection('Project Configuration');
+        printKeyValue('Name', projectName);
+        printKeyValue('Language', language);
+        printKeyValue('Model', model);
+        printKeyValue('Output', projectDir);
+        printKeyValue('Threshold', `${threshold}%`);
+        console.log();
+
+        printSection('Idea');
+        console.log(`  ${idea}`);
+        console.log();
+
+        // Check if directory exists
+        if (await projectDirExists(projectDir)) {
+          printWarning(`Directory already exists: ${projectDir}`);
+          printInfo('Use a different name or output directory');
+          process.exit(1);
+        }
+
+        // Require authentication
+        printSection('Authentication');
+        startSpinner('Checking authentication...');
+
+        try {
+          await requireAuth();
+          succeedSpinner('Authentication verified');
+        } catch (error) {
+          failSpinner('Authentication required');
+          printError(error instanceof Error ? error.message : 'Authentication failed');
+          process.exit(1);
+        }
+
+        // Generate project scaffold
+        if (!options.skipScaffold) {
+          printSection('Project Scaffolding');
+          startSpinner('Creating project structure...');
+
+          const scaffoldResult = await generateProject(spec, outputDir);
+
+          if (!scaffoldResult.success) {
+            failSpinner('Scaffolding failed');
+            printError(scaffoldResult.error || 'Failed to create project structure');
+            process.exit(1);
+          }
+
+          succeedSpinner(`Created ${scaffoldResult.filesCreated.length} files`);
+        }
+
+        // Run the workflow
+        printSection('Workflow Execution');
+
+        const workflowResult = await runWorkflow(spec, {
+          projectDir,
+          consensusConfig: {
+            threshold,
+            maxIterations,
+            openaiModel: model,
+          },
+          onProgress: (phase, message) => {
+            handleProgressUpdate(phase, message);
+          },
+        });
+
+        // Stop any running spinner
+        stopSpinner();
+
+        // Print results
+        console.log();
+        if (workflowResult.success) {
+          printHeader('Project Created Successfully!');
+
+          printSection('Summary');
+          printKeyValue('Location', projectDir);
+          printKeyValue('Language', language);
+
+          if (workflowResult.planResult?.consensusResult) {
+            printKeyValue('Final Consensus', `${workflowResult.planResult.consensusResult.finalScore}%`);
+            printKeyValue('Iterations', workflowResult.planResult.consensusResult.totalIterations.toString());
+          }
+
+          if (workflowResult.executionResult) {
+            printKeyValue('Tasks Completed', workflowResult.executionResult.completedTasks.toString());
+          }
+
+          console.log();
+          printSuccess('Your project is ready!');
+          console.log();
+          printInfo(`cd ${projectDir}`);
+          printInfo(language === 'python' ? 'python -m pytest tests/' : 'npm test');
+        } else {
+          printHeader('Project Creation Failed');
+
+          if (workflowResult.error) {
+            printError(workflowResult.error);
+          }
+
+          if (workflowResult.planResult?.consensusResult) {
+            printSection('Consensus Status');
+            printConsensusResult(
+              workflowResult.planResult.consensusResult.iterations[
+                workflowResult.planResult.consensusResult.iterations.length - 1
+              ]?.result || { score: 0, analysis: '', approved: false, rawResponse: '' }
+            );
+          }
+
+          // Cleanup on failure
+          printWarning('Cleaning up failed project...');
+          await cleanupProject(projectDir);
+
+          process.exit(1);
+        }
+      } catch (error) {
+        stopSpinner();
+        printError(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
+  return create;
+}
+
+/**
+ * Generate a project name from an idea
+ */
+function generateProjectName(idea: string): string {
+  // Take first few words, lowercase, replace spaces with hyphens
+  return idea
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, '')
+    .split(/\s+/)
+    .slice(0, 3)
+    .join('-')
+    .substring(0, 30) || 'my-project';
+}
+
+/**
+ * Handle progress updates from the workflow
+ */
+let currentSpinner: ReturnType<typeof startSpinner> | null = null;
+let lastPhase = '';
+
+function handleProgressUpdate(phase: string, message: string): void {
+  // Map phases to user-friendly names
+  const phaseNames: Record<string, string> = {
+    'plan-init': 'Initializing',
+    'expand-idea': 'Expanding Idea',
+    'get-context': 'Analyzing Context',
+    'create-plan': 'Creating Plan',
+    'consensus': 'Consensus Review',
+    'execution-start': 'Starting Execution',
+    'task-start': 'Executing Task',
+    'task-complete': 'Task Complete',
+    'task-failed': 'Task Failed',
+    'execution-complete': 'Execution Complete',
+    'complete': 'Complete',
+    'failed': 'Failed',
+    'error': 'Error',
+    'workflow': 'Workflow',
+  };
+
+  const phaseName = phaseNames[phase] || phase;
+
+  // Handle phase transitions
+  if (phase !== lastPhase) {
+    if (currentSpinner) {
+      if (phase === 'error' || phase === 'failed') {
+        failSpinner();
+      } else {
+        succeedSpinner();
+      }
+    }
+
+    if (!['complete', 'failed', 'error', 'task-complete', 'task-failed'].includes(phase)) {
+      currentSpinner = startSpinner(`${phaseName}: ${message}`);
+    }
+
+    lastPhase = phase;
+  } else if (currentSpinner) {
+    updateSpinner(`${phaseName}: ${message}`);
+  }
+
+  // Handle terminal phases
+  if (phase === 'complete') {
+    if (currentSpinner) {
+      succeedSpinner(message);
+      currentSpinner = null;
+    } else {
+      printSuccess(message);
+    }
+  } else if (phase === 'failed' || phase === 'error') {
+    if (currentSpinner) {
+      failSpinner(message);
+      currentSpinner = null;
+    } else {
+      printError(message);
+    }
+  } else if (phase === 'task-complete') {
+    printSuccess(message);
+  } else if (phase === 'task-failed') {
+    printError(message);
+  }
+}

package/src/cli/commands/index.ts

@@ -0,0 +1,10 @@
+/**
+ * CLI commands index
+ * Exports all command creators
+ */
+
+export { createAuthCommand } from './auth.js';
+export { createCreateCommand } from './create.js';
+export { createStatusCommand, createValidateCommand, createSummaryCommand } from './status.js';
+export { createResumeCommand, createResetCommand, createCancelCommand } from './resume.js';
+export { createConfigCommand } from './config.js';

package/src/cli/commands/resume.ts

@@ -0,0 +1,304 @@
+/**
+ * Resume command
+ * Resume an interrupted workflow
+ */
+
+import { Command } from 'commander';
+import path from 'node:path';
+import { requireAuth } from '../../auth/index.js';
+import {
+  resumeWorkflow,
+  getWorkflowStatus,
+  resetWorkflow,
+  cancelWorkflow,
+} from '../../workflow/index.js';
+import type { WorkflowPhase } from '../../types/workflow.js';
+import {
+  printHeader,
+  printSection,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  printKeyValue,
+  startSpinner,
+  updateSpinner,
+  succeedSpinner,
+  failSpinner,
+  stopSpinner,
+} from '../output.js';
+
+/**
+ * Create the resume command
+ */
+export function createResumeCommand(): Command {
+  const resume = new Command('resume')
+    .description('Resume an interrupted project workflow')
+    .argument('[directory]', 'Project directory', '.')
+    .option(
+      '--threshold <percent>',
+      'Consensus threshold percentage',
+      '95'
+    )
+    .option(
+      '--max-iterations <count>',
+      'Maximum consensus iterations',
+      '5'
+    )
+    .option(
+      '--max-retries <count>',
+      'Maximum task retries',
+      '3'
+    )
+    .action(async (directory: string, options) => {
+      const projectDir = path.resolve(directory);
+      const threshold = parseInt(options.threshold, 10);
+      const maxIterations = parseInt(options.maxIterations, 10);
+      const maxRetries = parseInt(options.maxRetries, 10);
+
+      try {
+        // Check project exists
+        const status = await getWorkflowStatus(projectDir);
+
+        if (!status.exists || !status.state) {
+          printError('No project found at this location');
+          printInfo('Run "popeye-cli create <idea>" to create a new project');
+          process.exit(1);
+        }
+
+        printHeader(`Resuming: ${status.state.name}`);
+
+        printSection('Current State');
+        printKeyValue('Phase', status.state.phase);
+        printKeyValue('Status', status.state.status);
+
+        if (status.progress) {
+          printKeyValue('Progress', `${status.progress.percentComplete}%`);
+        }
+
+        if (status.state.status === 'complete') {
+          printSuccess('Project is already complete!');
+          return;
+        }
+
+        // Require authentication
+        printSection('Authentication');
+        startSpinner('Checking authentication...');
+
+        try {
+          await requireAuth();
+          succeedSpinner('Authentication verified');
+        } catch (error) {
+          failSpinner('Authentication required');
+          printError(error instanceof Error ? error.message : 'Authentication failed');
+          process.exit(1);
+        }
+
+        // Resume workflow
+        printSection('Resuming Workflow');
+
+        const result = await resumeWorkflow(projectDir, {
+          consensusConfig: {
+            threshold,
+            maxIterations,
+          },
+          maxRetries,
+          onProgress: (phase, message) => {
+            handleProgressUpdate(phase, message);
+          },
+        });
+
+        // Stop any running spinner
+        stopSpinner();
+
+        // Print results
+        console.log();
+        if (result.success) {
+          printHeader('Workflow Complete!');
+
+          printSection('Summary');
+          printKeyValue('Phase', result.state.phase);
+          printKeyValue('Status', result.state.status);
+
+          if (result.executionResult) {
+            printKeyValue('Tasks Completed', result.executionResult.completedTasks.toString());
+          }
+
+          printSuccess('Project workflow completed successfully!');
+        } else {
+          printHeader('Workflow Failed');
+
+          if (result.error) {
+            printError(result.error);
+          }
+
+          printWarning('Run "popeye-cli resume" to try again');
+          process.exit(1);
+        }
+      } catch (error) {
+        stopSpinner();
+        printError(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
+  return resume;
+}
+
+/**
+ * Create the reset command
+ */
+export function createResetCommand(): Command {
+  const reset = new Command('reset')
+    .description('Reset project to a specific phase')
+    .argument('[directory]', 'Project directory', '.')
+    .option('-p, --phase <phase>', 'Phase to reset to (plan, execution)', 'plan')
+    .option('-f, --force', 'Force reset without confirmation')
+    .action(async (directory: string, options) => {
+      const projectDir = path.resolve(directory);
+      const phase = options.phase as WorkflowPhase;
+
+      if (!['plan', 'execution'].includes(phase)) {
+        printError(`Invalid phase: ${phase}. Use 'plan' or 'execution'.`);
+        process.exit(1);
+      }
+
+      try {
+        // Check project exists
+        const status = await getWorkflowStatus(projectDir);
+
+        if (!status.exists || !status.state) {
+          printError('No project found at this location');
+          process.exit(1);
+        }
+
+        if (!options.force) {
+          printWarning(`This will reset the project to the '${phase}' phase.`);
+          printWarning('A backup will be created before reset.');
+          printInfo('Use --force to skip this warning.');
+          // In a real implementation, we'd prompt for confirmation here
+        }
+
+        startSpinner(`Resetting to ${phase} phase...`);
+
+        await resetWorkflow(projectDir, phase);
+
+        succeedSpinner(`Reset to ${phase} phase`);
+        printSuccess('Project has been reset');
+        printInfo('Run "popeye-cli resume" to continue');
+      } catch (error) {
+        failSpinner('Reset failed');
+        printError(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
+  return reset;
+}
+
+/**
+ * Create the cancel command
+ */
+export function createCancelCommand(): Command {
+  const cancel = new Command('cancel')
+    .description('Cancel and delete a project')
+    .argument('[directory]', 'Project directory', '.')
+    .option('-f, --force', 'Force cancel without confirmation')
+    .action(async (directory: string, options) => {
+      const projectDir = path.resolve(directory);
+
+      try {
+        // Check project exists
+        const status = await getWorkflowStatus(projectDir);
+
+        if (!status.exists) {
+          printError('No project found at this location');
+          process.exit(1);
+        }
+
+        if (!options.force) {
+          printWarning('This will delete all project state and cannot be undone.');
+          printInfo('Use --force to skip this warning.');
+          // In a real implementation, we'd prompt for confirmation here
+        }
+
+        startSpinner('Cancelling project...');
+
+        const deleted = await cancelWorkflow(projectDir);
+
+        if (deleted) {
+          succeedSpinner('Project cancelled');
+          printSuccess('Project state has been deleted');
+        } else {
+          failSpinner('No state to delete');
+        }
+      } catch (error) {
+        failSpinner('Cancel failed');
+        printError(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
+  return cancel;
+}
+
+/**
+ * Handle progress updates from the workflow
+ */
+let currentSpinner: ReturnType<typeof startSpinner> | null = null;
+let lastPhase = '';
+
+function handleProgressUpdate(phase: string, message: string): void {
+  const phaseNames: Record<string, string> = {
+    'plan-init': 'Initializing',
+    'expand-idea': 'Expanding Idea',
+    'get-context': 'Analyzing Context',
+    'create-plan': 'Creating Plan',
+    'consensus': 'Consensus Review',
+    'execution-start': 'Starting Execution',
+    'task-start': 'Executing Task',
+    'task-complete': 'Task Complete',
+    'task-failed': 'Task Failed',
+    'execution-complete': 'Execution Complete',
+    'complete': 'Complete',
+    'failed': 'Failed',
+    'error': 'Error',
+    'workflow': 'Workflow',
+  };
+
+  const phaseName = phaseNames[phase] || phase;
+
+  if (phase !== lastPhase) {
+    if (currentSpinner) {
+      if (phase === 'error' || phase === 'failed') {
+        failSpinner();
+      } else {
+        succeedSpinner();
+      }
+    }
+
+    if (!['complete', 'failed', 'error', 'task-complete', 'task-failed'].includes(phase)) {
+      currentSpinner = startSpinner(`${phaseName}: ${message}`);
+    }
+
+    lastPhase = phase;
+  } else if (currentSpinner) {
+    updateSpinner(`${phaseName}: ${message}`);
+  }
+
+  if (phase === 'complete') {
+    if (currentSpinner) {
+      succeedSpinner(message);
+      currentSpinner = null;
+    } else {
+      printSuccess(message);
+    }
+  } else if (phase === 'failed' || phase === 'error') {
+    if (currentSpinner) {
+      failSpinner(message);
+      currentSpinner = null;
+    } else {
+      printError(message);
+    }
+  }
+}