wiggum-cli 0.9.7 → 0.10.0

package/src/cli.ts

@@ -1,274 +0,0 @@
-import { Command } from 'commander';
-import { displayHeader } from './utils/header.js';
-import { initCommand } from './commands/init.js';
-import { runCommand, type RunOptions } from './commands/run.js';
-import { monitorCommand, type MonitorOptions } from './commands/monitor.js';
-import { newCommand, type NewOptions } from './commands/new.js';
-import { logger } from './utils/logger.js';
-
-/**
- * Set up and configure the CLI
- */
-export function createCli(): Command {
-  const program = new Command();
-
-  program
-    .name('wiggum')
-    .description(
-      'AI-powered feature development loop CLI.\n\n' +
-        'Ralph auto-detects your tech stack and generates an intelligent\n' +
-        'development environment for AI-driven feature implementation.'
-    )
-    .version('0.1.0')
-    .hook('preAction', () => {
-      displayHeader();
-    })
-    .addHelpText(
-      'after',
-      `
-Examples:
-  $ wiggum init                    Initialize Wiggum with AI analysis
-  $ wiggum new my-feature          Create a new feature specification
-  $ wiggum run my-feature          Run the feature development loop
-  $ wiggum monitor my-feature      Monitor progress in real-time
-
-Documentation:
-  https://github.com/your-org/wiggum-cli#readme
-`
-    );
-
-  // wiggum init
-  program
-    .command('init')
-    .description(
-      'Initialize Ralph in the current project.\n\n' +
-        'Uses AI to analyze your codebase, detect the tech stack, and generate\n' +
-        'intelligent configuration files in .ralph/'
-    )
-    .option(
-      '--provider <name>',
-      'AI provider to use (anthropic, openai, openrouter)',
-      'anthropic'
-    )
-    .option('-y, --yes', 'Accept defaults and skip all confirmation prompts')
-    .option('-i, --interactive', 'Stay in interactive REPL mode after initialization')
-    .addHelpText(
-      'after',
-      `
-Examples:
-  $ wiggum init                           Initialize with AI analysis
-  $ wiggum init --provider openai         Use OpenAI provider
-  $ wiggum init --yes                     Non-interactive mode
-  $ wiggum init -i                        Initialize and enter interactive mode
-
-API Keys (BYOK - Bring Your Own Keys):
-  Required (one of):
-    ANTHROPIC_API_KEY    For Anthropic (Claude) provider
-    OPENAI_API_KEY       For OpenAI provider
-    OPENROUTER_API_KEY   For OpenRouter provider
-
-  Optional (for enhanced research):
-    TAVILY_API_KEY       Enable web search for best practices
-    CONTEXT7_API_KEY     Enable documentation lookup
-`
-    )
-    .action(async (options) => {
-      try {
-        await initCommand(options);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  // wiggum run <feature>
-  program
-    .command('run <feature>')
-    .description(
-      'Run the feature development loop for a specific feature.\n\n' +
-        'Executes the AI-driven implementation workflow using the feature\n' +
-        'spec in .ralph/specs/<feature>.md'
-    )
-    .option(
-      '--worktree',
-      'Use git worktree for isolation (enables parallel execution of multiple features)'
-    )
-    .option(
-      '--resume',
-      'Resume an interrupted loop (reuses existing branch and worktree)'
-    )
-    .option(
-      '--model <model>',
-      'Claude model to use for implementation (opus, sonnet)'
-    )
-    .option(
-      '--max-iterations <n>',
-      'Maximum number of implementation iterations (default: 50)',
-      parseInt
-    )
-    .option(
-      '--max-e2e-attempts <n>',
-      'Maximum E2E test retry attempts before giving up (default: 3)',
-      parseInt
-    )
-    .addHelpText(
-      'after',
-      `
-Examples:
-  $ wiggum run user-auth                     Run the user-auth feature
-  $ wiggum run payment --worktree            Run in isolated worktree
-  $ wiggum run payment --resume              Resume interrupted session
-  $ wiggum run my-feature --model opus       Use Claude Opus model
-  $ wiggum run my-feature --max-iterations 30 --max-e2e-attempts 5
-
-Notes:
-  - Create a feature spec first with: wiggum new <feature>
-  - The spec file should be at: .ralph/specs/<feature>.md
-  - Use --worktree to run multiple features in parallel
-`
-    )
-    .action(async (feature: string, options) => {
-      try {
-        const runOptions: RunOptions = {
-          worktree: options.worktree,
-          resume: options.resume,
-          model: options.model,
-          maxIterations: options.maxIterations,
-          maxE2eAttempts: options.maxE2eAttempts,
-        };
-        await runCommand(feature, runOptions);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  // wiggum monitor <feature>
-  program
-    .command('monitor <feature>')
-    .description(
-      'Launch the monitoring dashboard for a feature.\n\n' +
-        'Displays real-time progress including iteration count, phase,\n' +
-        'task completion, token usage, and E2E test status.'
-    )
-    .option(
-      '--bash',
-      'Use the bash script monitor instead of the built-in dashboard'
-    )
-    .option('--python', 'Use the Python TUI monitor (if available)')
-    .option(
-      '--interval <seconds>',
-      'Dashboard refresh interval in seconds (default: 5)',
-      parseInt,
-      5
-    )
-    .addHelpText(
-      'after',
-      `
-Examples:
-  $ wiggum monitor my-feature              Monitor with built-in dashboard
-  $ wiggum monitor my-feature --interval 2 Refresh every 2 seconds
-  $ wiggum monitor my-feature --bash       Use bash script monitor
-
-Dashboard Shows:
-  - Current phase (Planning, Implementation, E2E Testing, etc.)
-  - Iteration progress
-  - Task completion status
-  - Token usage (input/output)
-  - Git branch information
-`
-    )
-    .action(async (feature: string, options) => {
-      try {
-        const monitorOptions: MonitorOptions = {
-          bash: options.bash,
-          python: options.python,
-          interval: options.interval,
-        };
-        await monitorCommand(feature, monitorOptions);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  // wiggum new <feature>
-  program
-    .command('new <feature>')
-    .description(
-      'Create a new feature specification from template.\n\n' +
-        'Generates a markdown spec file with sections for requirements,\n' +
-        'acceptance criteria, technical notes, and more.'
-    )
-    .option('-e, --edit', 'Open the spec in your editor after creation')
-    .option(
-      '--editor <editor>',
-      'Editor command to use (defaults to $EDITOR or "code")'
-    )
-    .option('-y, --yes', 'Skip confirmation prompts')
-    .option('-f, --force', 'Overwrite existing spec file without prompting')
-    .option('--ai', 'Use AI interview to generate the spec')
-    .option('--tui', 'Use Ink TUI for AI interview (with --ai)')
-    .option(
-      '--provider <name>',
-      'AI provider for spec generation (anthropic, openai, openrouter)'
-    )
-    .option('--model <model>', 'Model to use for AI spec generation')
-    .addHelpText(
-      'after',
-      `
-Examples:
-  $ wiggum new user-dashboard              Create spec from template
-  $ wiggum new user-dashboard --ai         Use AI interview to generate spec
-  $ wiggum new user-dashboard --ai --tui   Use AI with Ink TUI interface
-  $ wiggum new user-dashboard --edit       Create and open in editor
-  $ wiggum new user-dashboard -e --editor vim  Open in vim
-  $ wiggum new user-dashboard --yes        Skip confirmations
-  $ wiggum new user-dashboard --force      Overwrite if exists
-
-Output:
-  Creates: .ralph/specs/<feature>.md
-
-AI Mode (--ai):
-  - Gathers context from URLs/files you provide
-  - Conducts an interview to understand your requirements
-  - Generates a detailed, project-specific specification
-  - Add --tui for a beautiful Ink-based terminal interface
-
-Template Mode (default):
-  - Uses a standard template with sections for:
-    Purpose, user stories, requirements, technical notes, etc.
-`
-    )
-    .action(async (feature: string, options) => {
-      try {
-        const newOptions: NewOptions = {
-          edit: options.edit,
-          editor: options.editor,
-          yes: options.yes,
-          force: options.force,
-          ai: options.ai,
-          tui: options.tui,
-          provider: options.provider,
-          model: options.model,
-        };
-        await newCommand(feature, newOptions);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  return program;
-}
-
-/**
- * Handle command errors with user-friendly output
- */
-function handleCommandError(error: unknown): void {
-  if (error instanceof Error) {
-    logger.error(error.message);
-    if (process.env.DEBUG) {
-      console.error(error.stack);
-    }
-  } else {
-    logger.error(String(error));
-  }
-  process.exit(1);
-}

package/src/repl/repl-loop.ts

@@ -1,389 +0,0 @@
-/**
- * REPL Loop
- * Main interactive loop for the Wiggum CLI
- */
-
-import readline from 'node:readline';
-import pc from 'picocolors';
-import { logger } from '../utils/logger.js';
-import { simpson } from '../utils/colors.js';
-import { runCommand } from '../commands/run.js';
-import { monitorCommand } from '../commands/monitor.js';
-import { runInitWorkflow } from '../commands/init.js';
-import { handleConfigCommand } from '../commands/config.js';
-import { hasConfig } from '../utils/config.js';
-import type { SessionState } from './session-state.js';
-import { updateSessionState } from './session-state.js';
-import {
-  parseInput,
-  resolveCommandAlias,
-  formatHelpText,
-  type ReplCommandName,
-} from './command-parser.js';
-
-const PROMPT = `${simpson.yellow('wiggum')}${simpson.brown('>')} `;
-
-/**
- * Clear any buffered stdin data
- * Prevents leaked input after subcommands that use their own stdin handling
- */
-async function clearStdinBuffer(): Promise<void> {
-  return new Promise((resolve) => {
-    if (process.stdin.isTTY) {
-      // Set raw mode temporarily to drain buffer
-      const wasRaw = process.stdin.isRaw;
-      process.stdin.setRawMode(true);
-      process.stdin.once('readable', () => {
-        // Drain any buffered data
-        while (process.stdin.read() !== null) {
-          // discard
-        }
-        process.stdin.setRawMode(wasRaw);
-        resolve();
-      });
-      // Trigger readable if nothing buffered
-      setTimeout(resolve, 10);
-    } else {
-      resolve();
-    }
-  });
-}
-
-/**
- * Handler for the /init command
- */
-async function handleInitCommand(
-  _args: string[],
-  state: SessionState,
-  rl: readline.Interface
-): Promise<SessionState> {
-  // Check if already initialized
-  if (state.initialized && hasConfig(state.projectRoot)) {
-    logger.warn('Project is already initialized. Re-running init will update configuration.');
-    console.log('');
-  }
-
-  // Close REPL readline to avoid conflicts with subcommand's stdin usage
-  // We'll signal to recreate it after the command completes
-  rl.close();
-
-  try {
-    const result = await runInitWorkflow(state.projectRoot, {
-      yes: false, // Always interactive in REPL
-    });
-
-    if (result) {
-      // Update state with init result
-      return updateSessionState(state, {
-        provider: result.provider,
-        model: result.model,
-        scanResult: result.scanResult,
-        config: result.config,
-        initialized: true,
-      });
-    }
-
-    // User cancelled
-    return state;
-  } catch (error) {
-    logger.error(`Init failed: ${error instanceof Error ? error.message : String(error)}`);
-    return state;
-  }
-}
-
-/**
- * Handler for the /new command
- * Always uses AI interview mode in REPL (falls back to template if no API key)
- */
-async function handleNewCommand(
-  args: string[],
-  state: SessionState,
-  rl: readline.Interface
-): Promise<SessionState> {
-  // Check if initialized
-  if (!state.initialized && !hasConfig(state.projectRoot)) {
-    logger.warn('Project not initialized. Run /init first.');
-    return state;
-  }
-
-  if (args.length === 0) {
-    logger.error('Feature name required. Usage: /new <feature-name>');
-    return state;
-  }
-
-  const featureName = args[0];
-
-  // Close REPL readline to avoid stdin conflicts with subcommand prompts
-  rl.close();
-
-  try {
-    // Delegate to the existing new command behavior
-    // Always use AI mode in REPL (the command handles fallback to template if no API key)
-    const { newCommand } = await import('../commands/new.js');
-    await newCommand(featureName, {
-      yes: false,
-      scanResult: state.scanResult,
-      provider: state.provider ?? undefined,
-      model: state.model,
-      ai: true, // Always use AI interview in REPL
-    });
-  } catch (error) {
-    logger.error(`New command failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-
-  return state;
-}
-
-/**
- * Handler for the /run command
- */
-async function handleRunCommand(
-  args: string[],
-  state: SessionState,
-  rl: readline.Interface
-): Promise<SessionState> {
-  // Check if initialized
-  if (!state.initialized && !hasConfig(state.projectRoot)) {
-    logger.warn('Project not initialized. Run /init first.');
-    return state;
-  }
-
-  if (args.length === 0) {
-    logger.error('Feature name required. Usage: /run <feature-name>');
-    return state;
-  }
-
-  const featureName = args[0];
-
-  // Close REPL readline to avoid stdin conflicts with subcommand
-  rl.close();
-
-  try {
-    await runCommand(featureName, {});
-  } catch (error) {
-    logger.error(`Run command failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-
-  return state;
-}
-
-/**
- * Handler for the /monitor command
- */
-async function handleMonitorCommand(
-  args: string[],
-  state: SessionState,
-  rl: readline.Interface
-): Promise<SessionState> {
-  if (args.length === 0) {
-    logger.error('Feature name required. Usage: /monitor <feature-name>');
-    return state;
-  }
-
-  const featureName = args[0];
-
-  // Close REPL readline to avoid stdin conflicts with subcommand
-  rl.close();
-
-  try {
-    await monitorCommand(featureName, {});
-  } catch (error) {
-    logger.error(`Monitor command failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-
-  return state;
-}
-
-/**
- * Handler for the /help command
- */
-function handleHelpCommand(): void {
-  console.log('');
-  console.log(formatHelpText());
-  console.log('');
-}
-
-/**
- * Execute a REPL command
- */
-async function executeCommand(
-  commandName: ReplCommandName,
-  args: string[],
-  state: SessionState,
-  rl: readline.Interface
-): Promise<{ state: SessionState; shouldExit: boolean; needsRlRecreate: boolean }> {
-  switch (commandName) {
-    case 'init':
-      // Init closes the readline to avoid stdin conflicts
-      return { state: await handleInitCommand(args, state, rl), shouldExit: false, needsRlRecreate: true };
-
-    case 'new':
-      return { state: await handleNewCommand(args, state, rl), shouldExit: false, needsRlRecreate: true };
-
-    case 'run':
-      return { state: await handleRunCommand(args, state, rl), shouldExit: false, needsRlRecreate: true };
-
-    case 'monitor':
-      return { state: await handleMonitorCommand(args, state, rl), shouldExit: false, needsRlRecreate: true };
-
-    case 'config':
-      return { state: await handleConfigCommand(args, state), shouldExit: false, needsRlRecreate: false };
-
-    case 'help':
-      handleHelpCommand();
-      return { state, shouldExit: false, needsRlRecreate: false };
-
-    case 'exit':
-      return { state, shouldExit: true, needsRlRecreate: false };
-
-    default:
-      logger.warn(`Unknown command: ${commandName}`);
-      return { state, shouldExit: false, needsRlRecreate: false };
-  }
-}
-
-/**
- * Handle natural language input
- * For now, just shows a message. Will be enhanced in Phase 3.
- */
-async function handleNaturalLanguage(
-  text: string,
-  state: SessionState
-): Promise<SessionState> {
-  if (state.conversationMode) {
-    // In conversation mode, pass to the conversation handler
-    // This will be implemented in Phase 3
-    console.log(pc.dim('(Conversation mode not yet implemented)'));
-  } else {
-    console.log('');
-    console.log(pc.dim('Tip: Use /help to see available commands, or /new <feature> to create a spec.'));
-    console.log('');
-  }
-
-  return state;
-}
-
-/**
- * Process a single line of input
- */
-async function processInput(
-  input: string,
-  state: SessionState,
-  rl: readline.Interface
-): Promise<{ state: SessionState; shouldExit: boolean; needsRlRecreate: boolean }> {
-  const parsed = parseInput(input);
-
-  switch (parsed.type) {
-    case 'empty':
-      return { state, shouldExit: false, needsRlRecreate: false };
-
-    case 'slash-command': {
-      const { command } = parsed;
-      if (!command) {
-        return { state, shouldExit: false, needsRlRecreate: false };
-      }
-
-      const resolvedName = resolveCommandAlias(command.name);
-      if (!resolvedName) {
-        logger.warn(`Unknown command: /${command.name}. Type /help for available commands.`);
-        return { state, shouldExit: false, needsRlRecreate: false };
-      }
-
-      return executeCommand(resolvedName, command.args, state, rl);
-    }
-
-    case 'natural-language': {
-      const newState = await handleNaturalLanguage(parsed.text!, state);
-      return { state: newState, shouldExit: false, needsRlRecreate: false };
-    }
-
-    default:
-      return { state, shouldExit: false, needsRlRecreate: false };
-  }
-}
-
-/**
- * Create a new readline interface
- */
-function createReadline(): readline.Interface {
-  return readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: PROMPT,
-    terminal: true,
-  });
-}
-
-/**
- * Read a single line from readline
- */
-function readLine(rl: readline.Interface): Promise<string | null> {
-  return new Promise((resolve) => {
-    rl.once('line', (line) => resolve(line));
-    rl.once('close', () => resolve(null));
-    rl.once('SIGINT', () => {
-      console.log('');
-      logger.info('Use /exit to quit');
-      rl.prompt();
-    });
-  });
-}
-
-/**
- * Start the REPL loop
- */
-export async function startRepl(initialState: SessionState): Promise<void> {
-  let state = initialState;
-
-  console.log('');
-  console.log(simpson.yellow('Wiggum Interactive Mode'));
-
-  // Show context-aware welcome message
-  if (!state.initialized && !hasConfig(state.projectRoot)) {
-    console.log(pc.dim('Not initialized. Run /init to set up this project.'));
-  } else {
-    console.log(pc.dim('Type /help for commands, /exit to quit'));
-  }
-  console.log('');
-
-  let rl = createReadline();
-  let running = true;
-
-  while (running) {
-    rl.prompt();
-    const line = await readLine(rl);
-
-    // Handle EOF (Ctrl+D)
-    if (line === null) {
-      console.log('');
-      logger.info('Goodbye!');
-      running = false;
-      break;
-    }
-
-    try {
-      const result = await processInput(line, state, rl);
-      state = result.state;
-
-      if (result.shouldExit) {
-        console.log('');
-        logger.info('Goodbye!');
-        rl.close();
-        running = false;
-        break;
-      }
-
-      // Recreate readline if needed (after commands that closed it)
-      if (result.needsRlRecreate) {
-        rl = createReadline();
-      }
-    } catch (error) {
-      logger.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-}
-
-/**
- * Export for testing
- */
-export { processInput, executeCommand };