popeye-cli 1.0.0 → 1.0.1

package/dist/cli/interactive.js

@@ -1,188 +1,301 @@
 /**
  * Interactive mode
- * REPL-style interface for Popeye CLI
+ * Claude Code-style interface for Popeye CLI
  */
 import * as readline from 'node:readline';
-import { getAuthStatusForDisplay } from '../auth/index.js';
+import { getAuthStatusForDisplay, authenticateClaude, authenticateOpenAI } 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 { printHeader, printSection, printSuccess, printError, printWarning, printInfo, printKeyValue, printAuthStatus, startSpinner, succeedSpinner, failSpinner, stopSpinner, clearConsole, theme, } from './output.js';
+import { printSuccess, printError, printWarning, printInfo, printKeyValue, startSpinner, succeedSpinner, failSpinner, stopSpinner, theme, } from './output.js';
 /**
- * Available slash commands
+ * Box drawing characters for Claude Code-style UI
  */
-const commands = {
-    '/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,
-    },
+const box = {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│',
+    leftT: '├',
+    rightT: '┤',
 };
 /**
- * Start interactive mode
+ * Get terminal width
  */
-export async function startInteractiveMode() {
-    clearConsole();
-    printHeader('Popeye CLI - Interactive Mode');
-    printInfo('Type your project idea or use /help for commands');
+function getTerminalWidth() {
+    return process.stdout.columns || 80;
+}
+/**
+ * Draw the header box
+ */
+function drawHeader() {
+    const width = getTerminalWidth();
+    const title = ' Popeye CLI ';
+    const subtitle = ' AI-Powered Code Generation ';
+    // Top border
+    console.log(theme.dim(box.topLeft + box.horizontal.repeat(width - 2) + box.topRight));
+    // Title line
+    const titlePadding = Math.floor((width - title.length - 2) / 2);
+    console.log(theme.dim(box.vertical) +
+        ' '.repeat(titlePadding) +
+        theme.primary.bold(title) +
+        ' '.repeat(width - titlePadding - title.length - 2) +
+        theme.dim(box.vertical));
+    // Subtitle line
+    const subPadding = Math.floor((width - subtitle.length - 2) / 2);
+    console.log(theme.dim(box.vertical) +
+        ' '.repeat(subPadding) +
+        theme.secondary(subtitle) +
+        ' '.repeat(width - subPadding - subtitle.length - 2) +
+        theme.dim(box.vertical));
+    // Bottom border
+    console.log(theme.dim(box.bottomLeft + box.horizontal.repeat(width - 2) + box.bottomRight));
+}
+/**
+ * Draw the input box frame
+ */
+function drawInputFrame(state) {
+    const width = getTerminalWidth();
+    // Status items
+    const langStatus = `${state.language}`;
+    const modelStatus = `${state.model}`;
+    const authStatus = state.claudeAuth && state.openaiAuth ? '●' : '○';
+    const authColor = state.claudeAuth && state.openaiAuth ? theme.success : theme.warning;
+    // Build status line
+    const statusItems = [
+        theme.dim('lang:') + theme.primary(langStatus),
+        theme.dim('model:') + theme.secondary(modelStatus),
+        authColor(authStatus) + theme.dim(' auth'),
+    ];
+    const statusText = statusItems.join(theme.dim(' │ '));
+    // Calculate visible length (without ANSI codes)
+    // eslint-disable-next-line no-control-regex
+    const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '');
+    const statusLen = stripAnsi(statusText).length;
+    // Top line with status
+    const topLine = box.topLeft +
+        box.horizontal.repeat(2) +
+        ' ' + stripAnsi(statusText) + ' ' +
+        box.horizontal.repeat(Math.max(0, width - statusLen - 6)) +
+        box.topRight;
+    console.log(theme.dim(topLine.slice(0, 1)) + statusText + theme.dim(topLine.slice(statusLen + 4)));
+}
+/**
+ * Clear screen and redraw UI
+ */
+function redrawUI(_state) {
+    console.clear();
+    drawHeader();
     console.log();
-    // Initialize state
-    const config = await loadConfig();
-    const state = {
-        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();
+}
+/**
+ * Prompt for input with styled prompt
+ */
+function getPrompt() {
+    return theme.dim(box.vertical) + ' ' + theme.primary('❯') + ' ';
+}
+/**
+ * Check and perform authentication
+ */
+async function ensureAuthentication(state) {
+    const status = await getAuthStatusForDisplay();
+    state.claudeAuth = status.claude.authenticated;
+    state.openaiAuth = status.openai.authenticated;
+    if (state.claudeAuth && state.openaiAuth) {
+        return true;
     }
-    // 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);
+    console.log();
+    printWarning('Authentication required to continue');
+    console.log();
+    // Authenticate Claude if needed
+    if (!state.claudeAuth) {
+        console.log(theme.dim(box.vertical) + ' ' + theme.primary('Claude CLI') + theme.dim(' - Browser authentication'));
+        console.log(theme.dim(box.vertical));
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const proceed = await new Promise((resolve) => {
+            rl.question(theme.dim(box.vertical) + '   Press Enter to open browser (or "skip" to skip): ', (answer) => {
+                rl.close();
+                resolve(answer.toLowerCase() !== 'skip');
+            });
+        });
+        if (proceed) {
+            startSpinner('Opening browser for Claude authentication...');
+            try {
+                const success = await authenticateClaude();
+                if (success) {
+                    succeedSpinner('Claude authenticated');
+                    state.claudeAuth = true;
                 }
                 else {
-                    printError(`Unknown command: ${command}. Use /help for available commands.`);
+                    failSpinner('Claude authentication failed');
                 }
             }
-            else {
-                // Treat as project idea
-                await handleIdea(input, state);
+            catch (err) {
+                failSpinner('Claude authentication failed');
+                printError(err instanceof Error ? err.message : 'Authentication failed');
             }
         }
-        catch (error) {
-            printError(error instanceof Error ? error.message : 'Unknown error');
-        }
         console.log();
-        rl.prompt();
-    });
-    rl.on('close', () => {
+    }
+    // Authenticate OpenAI if needed
+    if (!state.openaiAuth) {
+        console.log(theme.dim(box.vertical) + ' ' + theme.primary('OpenAI API') + theme.dim(' - API key required'));
+        console.log(theme.dim(box.vertical));
+        const rl2 = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const proceed2 = await new Promise((resolve) => {
+            rl2.question(theme.dim(box.vertical) + '   Press Enter to open key entry page (or "skip" to skip): ', (answer) => {
+                rl2.close();
+                resolve(answer.toLowerCase() !== 'skip');
+            });
+        });
+        if (proceed2) {
+            startSpinner('Opening browser for OpenAI API key entry...');
+            try {
+                const success = await authenticateOpenAI();
+                if (success) {
+                    succeedSpinner('OpenAI authenticated');
+                    state.openaiAuth = true;
+                }
+                else {
+                    failSpinner('OpenAI authentication failed');
+                }
+            }
+            catch (err) {
+                failSpinner('OpenAI authentication failed');
+                printError(err instanceof Error ? err.message : 'Authentication failed');
+            }
+        }
         console.log();
-        printInfo('Goodbye!');
-        process.exit(0);
-    });
+    }
+    return state.claudeAuth && state.openaiAuth;
 }
 /**
- * Handle /help command
+ * Display help
  */
-async function handleHelp(_args, _state) {
-    printSection('Available Commands');
-    for (const [cmd, info] of Object.entries(commands)) {
-        console.log(`  ${theme.primary(cmd.padEnd(15))} ${info.description}`);
+function showHelp() {
+    console.log();
+    console.log(theme.primary.bold('  Commands:'));
+    console.log();
+    const commands = [
+        ['/help', 'Show this help message'],
+        ['/status', 'Show current project status'],
+        ['/auth', 'Re-authenticate services'],
+        ['/config', 'Show configuration'],
+        ['/language <lang>', 'Set language (python/typescript)'],
+        ['/model <model>', 'Set OpenAI model'],
+        ['/resume', 'Resume interrupted project'],
+        ['/clear', 'Clear screen'],
+        ['/exit', 'Exit Popeye'],
+    ];
+    for (const [cmd, desc] of commands) {
+        console.log(`  ${theme.primary(cmd.padEnd(20))} ${theme.dim(desc)}`);
     }
     console.log();
-    printInfo('Or type a project idea to start creating');
+    console.log(theme.secondary('  Or just type your project idea to get started!'));
+    console.log();
+}
+/**
+ * Handle a command or idea
+ */
+async function handleInput(input, state) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return true;
+    // Handle commands
+    if (trimmed.startsWith('/')) {
+        const [cmd, ...args] = trimmed.split(/\s+/);
+        const command = cmd.toLowerCase();
+        switch (command) {
+            case '/help':
+                showHelp();
+                break;
+            case '/exit':
+            case '/quit':
+            case '/q':
+                console.log();
+                printInfo('Goodbye!');
+                return false;
+            case '/clear':
+                redrawUI(state);
+                break;
+            case '/status':
+                await handleStatus(state);
+                break;
+            case '/auth':
+                await ensureAuthentication(state);
+                break;
+            case '/config':
+                await handleConfig(state);
+                break;
+            case '/language':
+                handleLanguage(args, state);
+                break;
+            case '/model':
+                handleModel(args, state);
+                break;
+            case '/resume':
+                await handleResume(state);
+                break;
+            default:
+                printError(`Unknown command: ${cmd}`);
+                printInfo('Type /help for available commands');
+        }
+        return true;
+    }
+    // Handle as project idea
+    await handleIdea(trimmed, state);
+    return true;
 }
 /**
  * Handle /status command
  */
-async function handleStatus(_args, state) {
+async function handleStatus(state) {
+    console.log();
     if (!state.projectDir) {
-        printInfo('No project directory set. Use /project <dir> to set one.');
+        printInfo('No active project');
         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, state) {
-    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, state) {
+async function handleConfig(state) {
     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());
+    console.log();
+    console.log(theme.primary.bold('  Session:'));
+    console.log(`    ${theme.dim('Directory:')} ${state.projectDir || 'Not set'}`);
+    console.log(`    ${theme.dim('Language:')}  ${theme.primary(state.language)}`);
+    console.log(`    ${theme.dim('Model:')}     ${theme.secondary(state.model)}`);
+    console.log(`    ${theme.dim('Claude:')}    ${state.claudeAuth ? theme.success('●') : theme.error('○')}`);
+    console.log(`    ${theme.dim('OpenAI:')}    ${state.openaiAuth ? theme.success('●') : theme.error('○')}`);
+    console.log();
+    console.log(theme.primary.bold('  Consensus:'));
+    console.log(`    ${theme.dim('Threshold:')} ${config.consensus.threshold}%`);
+    console.log(`    ${theme.dim('Max Iterations:')} ${config.consensus.max_disagreements}`);
+    console.log();
 }
 /**
  * Handle /language command
  */
-async function handleLanguage(args, state) {
+function handleLanguage(args, state) {
     if (args.length === 0) {
+        console.log();
         printKeyValue('Current language', state.language);
         printInfo('Use /language <python|typescript> to change');
         return;
@@ -193,16 +306,18 @@ async function handleLanguage(args, state) {
         return;
     }
     state.language = lang;
-    printSuccess(`Language set to: ${lang}`);
+    console.log();
+    printSuccess(`Language set to ${lang}`);
 }
 /**
  * Handle /model command
  */
-async function handleModel(args, state) {
+function handleModel(args, state) {
     const validModels = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'];
     if (args.length === 0) {
+        console.log();
         printKeyValue('Current model', state.model);
-        printInfo(`Use /model <${validModels.join('|')}> to change`);
+        printInfo(`Available: ${validModels.join(', ')}`);
         return;
     }
     const model = args[0];
@@ -211,32 +326,19 @@ async function handleModel(args, state) {
         return;
     }
     state.model = model;
-    printSuccess(`Model set to: ${model}`);
-}
-/**
- * Handle /project command
- */
-async function handleProject(args, state) {
-    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}`);
+    console.log();
+    printSuccess(`Model set to ${model}`);
 }
 /**
  * Handle /resume command
  */
-async function handleResume(_args, state) {
+async function handleResume(state) {
     if (!state.projectDir) {
-        printError('No project directory set. Use /project <dir> first.');
+        printError('No project directory set');
         return;
     }
-    if (!state.authenticated) {
-        printError('Not authenticated. Run "popeye-cli auth login" first.');
+    if (!state.claudeAuth || !state.openaiAuth) {
+        printError('Authentication required. Run /auth first.');
         return;
     }
     const status = await getWorkflowStatus(state.projectDir);
@@ -244,13 +346,15 @@ async function handleResume(_args, state) {
         printError('No project found to resume');
         return;
     }
+    console.log();
     printInfo('Resuming workflow...');
     console.log();
     const result = await resumeWorkflow(state.projectDir, {
         onProgress: (phase, message) => {
-            console.log(`  [${phase}] ${message}`);
+            console.log(`  ${theme.dim(`[${phase}]`)} ${message}`);
         },
     });
+    console.log();
     if (result.success) {
         printSuccess('Workflow completed!');
     }
@@ -258,33 +362,28 @@ async function handleResume(_args, state) {
         printError(result.error || 'Workflow failed');
     }
 }
-/**
- * Handle /clear command
- */
-async function handleClear(_args, _state) {
-    clearConsole();
-}
-/**
- * Handle /exit command
- */
-async function handleExit(_args, _state) {
-    printInfo('Goodbye!');
-    process.exit(0);
-}
 /**
  * Handle project idea input
  */
 async function handleIdea(idea, state) {
-    if (!state.authenticated) {
-        printError('Not authenticated. Run /auth to check status.');
-        return;
+    if (!state.claudeAuth || !state.openaiAuth) {
+        console.log();
+        printError('Authentication required');
+        printInfo('Running authentication flow...');
+        console.log();
+        const authenticated = await ensureAuthentication(state);
+        if (!authenticated) {
+            printWarning('Skipping project creation - authentication incomplete');
+            return;
+        }
     }
-    printSection('Creating Project');
-    printKeyValue('Idea', idea);
-    printKeyValue('Language', state.language);
-    printKeyValue('Model', state.model);
     console.log();
-    // Generate project name
+    console.log(theme.primary.bold('  Creating Project'));
+    console.log(`    ${theme.dim('Idea:')} ${idea}`);
+    console.log(`    ${theme.dim('Language:')} ${theme.primary(state.language)}`);
+    console.log(`    ${theme.dim('Model:')} ${theme.secondary(state.model)}`);
+    console.log();
+    // Generate project name from idea
     const projectName = idea
         .toLowerCase()
         .replace(/[^a-z0-9\s]/g, '')
@@ -311,20 +410,77 @@ async function handleIdea(idea, state) {
     }
     succeedSpinner(`Created ${scaffoldResult.filesCreated.length} files`);
     // Run workflow
+    console.log();
+    printInfo('Starting AI workflow...');
+    console.log();
     const workflowResult = await runWorkflow(spec, {
         projectDir,
         onProgress: (phase, message) => {
-            console.log(`  [${phase}] ${message}`);
+            console.log(`  ${theme.dim(`[${phase}]`)} ${message}`);
         },
     });
     stopSpinner();
+    console.log();
     if (workflowResult.success) {
         printSuccess('Project created successfully!');
-        printKeyValue('Location', projectDir);
+        console.log(`    ${theme.dim('Location:')} ${projectDir}`);
         state.projectDir = projectDir;
     }
     else {
         printError(workflowResult.error || 'Workflow failed');
     }
 }
+/**
+ * Start interactive mode with auto-authentication
+ */
+export async function startInteractiveMode() {
+    console.clear();
+    // Initialize state
+    const config = await loadConfig();
+    const state = {
+        projectDir: process.cwd(),
+        language: config.project.default_language,
+        model: config.apis.openai.model,
+        claudeAuth: false,
+        openaiAuth: false,
+    };
+    // Draw header
+    drawHeader();
+    console.log();
+    // Check and perform authentication
+    const isAuthenticated = await ensureAuthentication(state);
+    if (!isAuthenticated) {
+        console.log();
+        printWarning('Some services are not authenticated. Some features may not work.');
+        printInfo('You can authenticate later with /auth');
+    }
+    else {
+        console.log();
+        printSuccess('Ready! Type your project idea or /help for commands');
+    }
+    console.log();
+    // Create readline interface
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    // Input loop
+    const promptUser = () => {
+        drawInputFrame(state);
+        rl.question(getPrompt(), async (input) => {
+            // Clear the input frame line
+            process.stdout.write('\x1b[1A\x1b[2K'); // Move up and clear
+            const shouldContinue = await handleInput(input, state);
+            if (shouldContinue) {
+                console.log();
+                promptUser();
+            }
+            else {
+                rl.close();
+                process.exit(0);
+            }
+        });
+    };
+    promptUser();
+}
 //# sourceMappingURL=interactive.js.map