popeye-cli 1.0.0

package/src/cli/commands/status.ts

@@ -0,0 +1,189 @@
+/**
+ * Status command
+ * Shows project status and progress
+ */
+
+import { Command } from 'commander';
+import path from 'node:path';
+import {
+  getWorkflowStatus,
+  getWorkflowSummary,
+  validateReadyForExecution,
+} from '../../workflow/index.js';
+import {
+  printHeader,
+  printSection,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  printKeyValue,
+  printProgress,
+  printProjectState,
+  startSpinner,
+  succeedSpinner,
+  failSpinner,
+} from '../output.js';
+
+/**
+ * Create the status command
+ */
+export function createStatusCommand(): Command {
+  const status = new Command('status')
+    .description('Show project status')
+    .argument('[directory]', 'Project directory', '.')
+    .option('-v, --verbose', 'Show detailed status')
+    .option('--json', 'Output as JSON')
+    .action(async (directory: string, options) => {
+      const projectDir = path.resolve(directory);
+
+      startSpinner('Loading project status...');
+
+      try {
+        const status = await getWorkflowStatus(projectDir);
+
+        if (!status.exists) {
+          failSpinner('No project found');
+          printInfo(`No Popeye project found at: ${projectDir}`);
+          printInfo('Run "popeye-cli create <idea>" to create a new project');
+          process.exit(1);
+        }
+
+        succeedSpinner('Status loaded');
+
+        // JSON output
+        if (options.json) {
+          console.log(JSON.stringify({ status, progress: status.progress }, null, 2));
+          return;
+        }
+
+        // Verbose output
+        if (options.verbose && status.state) {
+          printProjectState(status.state);
+          return;
+        }
+
+        // Standard output
+        const state = status.state!;
+        const progress = status.progress!;
+
+        printHeader(`Project: ${state.name}`);
+
+        printSection('Status');
+        printKeyValue('Phase', state.phase);
+        printKeyValue('Status', state.status);
+        printKeyValue('Language', state.language);
+
+        printSection('Progress');
+        printKeyValue('Milestones', `${progress.completedMilestones}/${progress.totalMilestones}`);
+        printKeyValue('Tasks', `${progress.completedTasks}/${progress.totalTasks}`);
+        printProgress(progress.completedTasks, progress.totalTasks);
+
+        // Show current work
+        if (state.currentMilestone) {
+          const milestone = state.milestones.find((m) => m.id === state.currentMilestone);
+          if (milestone) {
+            printSection('Current Work');
+            printKeyValue('Milestone', milestone.name);
+
+            if (state.currentTask) {
+              const task = milestone.tasks.find((t) => t.id === state.currentTask);
+              if (task) {
+                printKeyValue('Task', task.name);
+              }
+            }
+          }
+        }
+
+        // Show consensus info
+        if (state.consensusHistory && state.consensusHistory.length > 0) {
+          const lastConsensus = state.consensusHistory[state.consensusHistory.length - 1];
+          printSection('Consensus');
+          printKeyValue('Last Score', `${lastConsensus.result.score}%`);
+          printKeyValue('Iterations', state.consensusHistory.length.toString());
+        }
+
+        // Show errors
+        if (state.error) {
+          printSection('Error');
+          printError(state.error);
+        }
+
+        // Show next steps
+        console.log();
+        if (state.status === 'complete') {
+          printSuccess('Project is complete!');
+        } else if (state.status === 'failed') {
+          printWarning('Project failed. Run "popeye-cli resume" to retry.');
+        } else if (state.phase === 'plan') {
+          printInfo('Run "popeye-cli resume" to continue planning.');
+        } else {
+          printInfo('Run "popeye-cli resume" to continue execution.');
+        }
+      } catch (error) {
+        failSpinner('Failed to load status');
+        printError(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
+  return status;
+}
+
+/**
+ * Create the validate command
+ */
+export function createValidateCommand(): Command {
+  const validate = new Command('validate')
+    .description('Validate project is ready for execution')
+    .argument('[directory]', 'Project directory', '.')
+    .action(async (directory: string) => {
+      const projectDir = path.resolve(directory);
+
+      startSpinner('Validating project...');
+
+      try {
+        const result = await validateReadyForExecution(projectDir);
+
+        if (result.ready) {
+          succeedSpinner('Project is valid and ready for execution');
+          printSuccess('All validation checks passed');
+        } else {
+          failSpinner('Project validation failed');
+          printSection('Issues Found');
+          for (const issue of result.issues) {
+            printWarning(issue);
+          }
+          process.exit(1);
+        }
+      } catch (error) {
+        failSpinner('Validation failed');
+        printError(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
+  return validate;
+}
+
+/**
+ * Create the summary command
+ */
+export function createSummaryCommand(): Command {
+  const summary = new Command('summary')
+    .description('Show detailed project summary')
+    .argument('[directory]', 'Project directory', '.')
+    .action(async (directory: string) => {
+      const projectDir = path.resolve(directory);
+
+      try {
+        const summaryText = await getWorkflowSummary(projectDir);
+        console.log(summaryText);
+      } catch (error) {
+        printError(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
+  return summary;
+}

package/src/cli/index.ts

@@ -0,0 +1,90 @@
+/**
+ * CLI module index
+ * Main entry point for the CLI interface
+ */
+
+import { Command } from 'commander';
+import {
+  createAuthCommand,
+  createCreateCommand,
+  createStatusCommand,
+  createValidateCommand,
+  createSummaryCommand,
+  createResumeCommand,
+  createResetCommand,
+  createCancelCommand,
+  createConfigCommand,
+} from './commands/index.js';
+import { startInteractiveMode } from './interactive.js';
+import { printHeader, printError, theme } from './output.js';
+
+// Re-export
+export * from './output.js';
+export * from './interactive.js';
+export * from './commands/index.js';
+
+/**
+ * Package version (will be replaced during build)
+ */
+const VERSION = '1.0.0';
+
+/**
+ * Create the main CLI program
+ */
+export function createProgram(): Command {
+  const program = new Command();
+
+  program
+    .name('popeye-cli')
+    .description('Fully autonomous code generation powered by Claude CLI and OpenAI consensus')
+    .version(VERSION)
+    .option('-v, --verbose', 'Enable verbose output')
+    .option('--no-color', 'Disable colored output');
+
+  // Add commands
+  program.addCommand(createAuthCommand());
+  program.addCommand(createCreateCommand());
+  program.addCommand(createStatusCommand());
+  program.addCommand(createValidateCommand());
+  program.addCommand(createSummaryCommand());
+  program.addCommand(createResumeCommand());
+  program.addCommand(createResetCommand());
+  program.addCommand(createCancelCommand());
+  program.addCommand(createConfigCommand());
+
+  // Interactive mode command
+  program
+    .command('interactive')
+    .alias('i')
+    .description('Start interactive mode')
+    .action(async () => {
+      await startInteractiveMode();
+    });
+
+  // Default action (no command specified)
+  program.action(async (_options, command) => {
+    // If no command specified and no arguments, show help
+    if (command.args.length === 0) {
+      printHeader('Popeye CLI');
+      console.log(theme.secondary('Autonomous code generation powered by AI consensus'));
+      console.log();
+      program.outputHelp();
+    }
+  });
+
+  return program;
+}
+
+/**
+ * Run the CLI
+ */
+export async function runCLI(args: string[] = process.argv): Promise<void> {
+  const program = createProgram();
+
+  try {
+    await program.parseAsync(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : 'Unknown error');
+    process.exit(1);
+  }
+}

package/src/cli/interactive.ts

@@ -0,0 +1,418 @@
+/**
+ * Interactive mode
+ * REPL-style interface for Popeye CLI
+ */
+
+import * as readline from 'node:readline';
+import { getAuthStatusForDisplay } from '../auth/index.js';
+import {
+  runWorkflow,
+  resumeWorkflow,
+  getWorkflowStatus,
+  getWorkflowSummary,
+} from '../workflow/index.js';
+import { generateProject } from '../generators/index.js';
+import { loadConfig } from '../config/index.js';
+import type { ProjectSpec, OutputLanguage, OpenAIModel } from '../types/project.js';
+import {
+  printHeader,
+  printSection,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  printKeyValue,
+  printAuthStatus,
+  startSpinner,
+  succeedSpinner,
+  failSpinner,
+  stopSpinner,
+  clearConsole,
+  theme,
+} from './output.js';
+
+/**
+ * Interactive session state
+ */
+interface SessionState {
+  projectDir: string | null;
+  language: OutputLanguage;
+  model: OpenAIModel;
+  authenticated: boolean;
+}
+
+/**
+ * Command handler type
+ */
+type CommandHandler = (args: string[], state: SessionState) => Promise<void>;
+
+/**
+ * Available slash commands
+ */
+const commands: Record<string, { description: string; handler: CommandHandler }> = {
+  '/help': {
+    description: 'Show available commands',
+    handler: handleHelp,
+  },
+  '/status': {
+    description: 'Show current project status',
+    handler: handleStatus,
+  },
+  '/auth': {
+    description: 'Check authentication status',
+    handler: handleAuth,
+  },
+  '/config': {
+    description: 'Show current configuration',
+    handler: handleConfig,
+  },
+  '/language': {
+    description: 'Set output language (python/typescript)',
+    handler: handleLanguage,
+  },
+  '/model': {
+    description: 'Set OpenAI model',
+    handler: handleModel,
+  },
+  '/project': {
+    description: 'Set project directory',
+    handler: handleProject,
+  },
+  '/resume': {
+    description: 'Resume current project workflow',
+    handler: handleResume,
+  },
+  '/clear': {
+    description: 'Clear the screen',
+    handler: handleClear,
+  },
+  '/exit': {
+    description: 'Exit interactive mode',
+    handler: handleExit,
+  },
+  '/quit': {
+    description: 'Exit interactive mode',
+    handler: handleExit,
+  },
+};
+
+/**
+ * Start interactive mode
+ */
+export async function startInteractiveMode(): Promise<void> {
+  clearConsole();
+  printHeader('Popeye CLI - Interactive Mode');
+
+  printInfo('Type your project idea or use /help for commands');
+  console.log();
+
+  // Initialize state
+  const config = await loadConfig();
+  const state: SessionState = {
+    projectDir: process.cwd(),
+    language: config.project.default_language,
+    model: config.apis.openai.model,
+    authenticated: false,
+  };
+
+  // Check authentication
+  const authStatus = await getAuthStatusForDisplay();
+  state.authenticated = authStatus.claude.authenticated && authStatus.openai.authenticated;
+
+  if (!state.authenticated) {
+    printWarning('Not fully authenticated. Run /auth to check status.');
+    console.log();
+  }
+
+  // Create readline interface
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: theme.primary('popeye> '),
+  });
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+
+    try {
+      if (input.startsWith('/')) {
+        // Handle command
+        const [command, ...args] = input.split(/\s+/);
+        const cmd = commands[command.toLowerCase()];
+
+        if (cmd) {
+          await cmd.handler(args, state);
+        } else {
+          printError(`Unknown command: ${command}. Use /help for available commands.`);
+        }
+      } else {
+        // Treat as project idea
+        await handleIdea(input, state);
+      }
+    } catch (error) {
+      printError(error instanceof Error ? error.message : 'Unknown error');
+    }
+
+    console.log();
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    console.log();
+    printInfo('Goodbye!');
+    process.exit(0);
+  });
+}
+
+/**
+ * Handle /help command
+ */
+async function handleHelp(_args: string[], _state: SessionState): Promise<void> {
+  printSection('Available Commands');
+
+  for (const [cmd, info] of Object.entries(commands)) {
+    console.log(`  ${theme.primary(cmd.padEnd(15))} ${info.description}`);
+  }
+
+  console.log();
+  printInfo('Or type a project idea to start creating');
+}
+
+/**
+ * Handle /status command
+ */
+async function handleStatus(_args: string[], state: SessionState): Promise<void> {
+  if (!state.projectDir) {
+    printInfo('No project directory set. Use /project <dir> to set one.');
+    return;
+  }
+
+  const status = await getWorkflowStatus(state.projectDir);
+
+  if (!status.exists) {
+    printInfo('No project found in current directory');
+    printKeyValue('Directory', state.projectDir);
+    printKeyValue('Language', state.language);
+    printKeyValue('Model', state.model);
+    return;
+  }
+
+  const summary = await getWorkflowSummary(state.projectDir);
+  console.log(summary);
+}
+
+/**
+ * Handle /auth command
+ */
+async function handleAuth(_args: string[], state: SessionState): Promise<void> {
+  const status = await getAuthStatusForDisplay();
+  printAuthStatus(status);
+
+  state.authenticated = status.claude.authenticated && status.openai.authenticated;
+
+  if (!state.authenticated) {
+    console.log();
+    printInfo('Run "popeye-cli auth login" to authenticate');
+  }
+}
+
+/**
+ * Handle /config command
+ */
+async function handleConfig(_args: string[], state: SessionState): Promise<void> {
+  const config = await loadConfig();
+
+  printSection('Current Session');
+  printKeyValue('Project Dir', state.projectDir || 'Not set');
+  printKeyValue('Language', state.language);
+  printKeyValue('Model', state.model);
+  printKeyValue('Authenticated', state.authenticated ? 'Yes' : 'No');
+
+  printSection('Configuration');
+  printKeyValue('Threshold', `${config.consensus.threshold}%`);
+  printKeyValue('Max Iterations', config.consensus.max_disagreements.toString());
+}
+
+/**
+ * Handle /language command
+ */
+async function handleLanguage(args: string[], state: SessionState): Promise<void> {
+  if (args.length === 0) {
+    printKeyValue('Current language', state.language);
+    printInfo('Use /language <python|typescript> to change');
+    return;
+  }
+
+  const lang = args[0].toLowerCase() as OutputLanguage;
+  if (!['python', 'typescript'].includes(lang)) {
+    printError('Invalid language. Use: python or typescript');
+    return;
+  }
+
+  state.language = lang;
+  printSuccess(`Language set to: ${lang}`);
+}
+
+/**
+ * Handle /model command
+ */
+async function handleModel(args: string[], state: SessionState): Promise<void> {
+  const validModels = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'];
+
+  if (args.length === 0) {
+    printKeyValue('Current model', state.model);
+    printInfo(`Use /model <${validModels.join('|')}> to change`);
+    return;
+  }
+
+  const model = args[0] as OpenAIModel;
+  if (!validModels.includes(model)) {
+    printError(`Invalid model. Use one of: ${validModels.join(', ')}`);
+    return;
+  }
+
+  state.model = model;
+  printSuccess(`Model set to: ${model}`);
+}
+
+/**
+ * Handle /project command
+ */
+async function handleProject(args: string[], state: SessionState): Promise<void> {
+  const path = await import('node:path');
+
+  if (args.length === 0) {
+    printKeyValue('Current directory', state.projectDir || 'Not set');
+    printInfo('Use /project <directory> to change');
+    return;
+  }
+
+  const dir = path.resolve(args[0]);
+  state.projectDir = dir;
+  printSuccess(`Project directory set to: ${dir}`);
+}
+
+/**
+ * Handle /resume command
+ */
+async function handleResume(_args: string[], state: SessionState): Promise<void> {
+  if (!state.projectDir) {
+    printError('No project directory set. Use /project <dir> first.');
+    return;
+  }
+
+  if (!state.authenticated) {
+    printError('Not authenticated. Run "popeye-cli auth login" first.');
+    return;
+  }
+
+  const status = await getWorkflowStatus(state.projectDir);
+
+  if (!status.exists) {
+    printError('No project found to resume');
+    return;
+  }
+
+  printInfo('Resuming workflow...');
+  console.log();
+
+  const result = await resumeWorkflow(state.projectDir, {
+    onProgress: (phase, message) => {
+      console.log(`  [${phase}] ${message}`);
+    },
+  });
+
+  if (result.success) {
+    printSuccess('Workflow completed!');
+  } else {
+    printError(result.error || 'Workflow failed');
+  }
+}
+
+/**
+ * Handle /clear command
+ */
+async function handleClear(_args: string[], _state: SessionState): Promise<void> {
+  clearConsole();
+}
+
+/**
+ * Handle /exit command
+ */
+async function handleExit(_args: string[], _state: SessionState): Promise<void> {
+  printInfo('Goodbye!');
+  process.exit(0);
+}
+
+/**
+ * Handle project idea input
+ */
+async function handleIdea(idea: string, state: SessionState): Promise<void> {
+  if (!state.authenticated) {
+    printError('Not authenticated. Run /auth to check status.');
+    return;
+  }
+
+  printSection('Creating Project');
+  printKeyValue('Idea', idea);
+  printKeyValue('Language', state.language);
+  printKeyValue('Model', state.model);
+  console.log();
+
+  // Generate project name
+  const projectName = idea
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, '')
+    .split(/\s+/)
+    .slice(0, 3)
+    .join('-')
+    .substring(0, 30) || 'my-project';
+
+  const path = await import('node:path');
+  const projectDir = path.join(state.projectDir || process.cwd(), projectName);
+
+  const spec: ProjectSpec = {
+    idea,
+    name: projectName,
+    language: state.language,
+    openaiModel: state.model,
+    outputDir: state.projectDir || process.cwd(),
+  };
+
+  // Generate scaffold
+  startSpinner('Creating project structure...');
+  const scaffoldResult = await generateProject(spec, state.projectDir || process.cwd());
+
+  if (!scaffoldResult.success) {
+    failSpinner('Scaffolding failed');
+    printError(scaffoldResult.error || 'Failed to create project');
+    return;
+  }
+
+  succeedSpinner(`Created ${scaffoldResult.filesCreated.length} files`);
+
+  // Run workflow
+  const workflowResult = await runWorkflow(spec, {
+    projectDir,
+    onProgress: (phase, message) => {
+      console.log(`  [${phase}] ${message}`);
+    },
+  });
+
+  stopSpinner();
+
+  if (workflowResult.success) {
+    printSuccess('Project created successfully!');
+    printKeyValue('Location', projectDir);
+    state.projectDir = projectDir;
+  } else {
+    printError(workflowResult.error || 'Workflow failed');
+  }
+}