wiggum-cli 0.5.4 → 0.7.0

package/src/commands/new.ts

@@ -1,6 +1,6 @@
 /**
  * New Command
- * Create a new feature specification from template
+ * Create a new feature specification from template or AI interview
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
@@ -9,6 +9,9 @@ import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
 import { logger } from '../utils/logger.js';
 import { loadConfigWithDefaults, hasConfig } from '../utils/config.js';
+import { getAvailableProvider, type AIProvider, AVAILABLE_MODELS } from '../ai/providers.js';
+import { SpecGenerator } from '../ai/conversation/index.js';
+import { Scanner, type ScanResult } from '../scanner/index.js';
 import pc from 'picocolors';
 import * as prompts from '@clack/prompts';
 
@@ -21,6 +24,14 @@ export interface NewOptions {
   yes?: boolean;
   /** Force overwrite if file exists */
   force?: boolean;
+  /** Use AI interview to generate spec */
+  ai?: boolean;
+  /** AI provider (anthropic, openai, openrouter) */
+  provider?: AIProvider;
+  /** Model to use for AI generation */
+  model?: string;
+  /** Pre-loaded scan result (from REPL session) */
+  scanResult?: ScanResult;
 }
 
 /**
@@ -97,6 +108,15 @@ Describe what this feature does and why it's needed.
 - [ ] Question 2 - Clarification required
 `;
 
+/**
+ * Get default model for a provider
+ */
+function getDefaultModelForProvider(provider: AIProvider): string {
+  const models = AVAILABLE_MODELS[provider];
+  const recommended = models.find(m => m.hint?.includes('recommended'));
+  return recommended?.value || models[0].value;
+}
+
 /**
  * Find the _example.md template
  */
@@ -178,7 +198,7 @@ export async function newCommand(feature: string, options: NewOptions = {}): Pro
   // Sanitize feature name (allow alphanumeric, hyphens, underscores)
   if (!/^[a-zA-Z0-9_-]+$/.test(feature)) {
     logger.error('Feature name must contain only letters, numbers, hyphens, and underscores');
-    logger.info('Example: ralph new my-feature or ralph new user_auth');
+    logger.info('Example: wiggum new my-feature or wiggum new user_auth');
     process.exit(1);
   }
 
@@ -194,7 +214,7 @@ export async function newCommand(feature: string, options: NewOptions = {}): Pro
 
   // Check for config
   if (!hasConfig(projectRoot)) {
-    logger.warn('No ralph.config.js found. Run "ralph init" first to configure your project.');
+    logger.warn('No ralph.config.cjs found. Run "wiggum init" first to configure your project.');
     logger.info('Using default paths...');
     console.log('');
   }
@@ -234,55 +254,112 @@ export async function newCommand(feature: string, options: NewOptions = {}): Pro
     logger.warn('Overwriting existing spec file');
   }
 
-  // Find or use default template
-  let templateContent: string;
+  // Determine if we should use AI generation
+  const provider = options.provider || getAvailableProvider();
+  const useAi = options.ai && provider !== null;
 
-  // Try to find _example.md template
-  const exampleTemplate = await findExampleTemplate(projectRoot);
-  if (exampleTemplate) {
-    logger.info(`Using template: ${exampleTemplate}`);
-    templateContent = readFileSync(exampleTemplate, 'utf-8');
-  } else {
-    // Try package template
-    const packageTemplateDir = getPackageTemplateDir();
-    const packageTemplate = join(packageTemplateDir, '_example.md.tmpl');
-    if (existsSync(packageTemplate)) {
-      logger.info(`Using package template`);
-      templateContent = readFileSync(packageTemplate, 'utf-8');
-    } else {
-      // Use default template
-      logger.info('Using default template');
-      templateContent = DEFAULT_SPEC_TEMPLATE;
-    }
-  }
+  let specContent: string;
 
-  // Process template
-  const specContent = processTemplate(templateContent, feature);
+  if (useAi && provider) {
+    // Use AI-powered spec generation
+    const model = options.model || getDefaultModelForProvider(provider);
+    logger.info(`Using AI spec generation (${provider}/${model})`);
 
-  // Confirm with user (unless --yes)
-  if (!options.yes) {
-    console.log('');
-    console.log(pc.cyan('--- Spec Preview ---'));
-    console.log(`File: ${specPath}`);
-    console.log('');
-
-    // Show first few lines of the processed template
-    const previewLines = specContent.split('\n').slice(0, 15);
-    console.log(pc.dim(previewLines.join('\n')));
-    if (specContent.split('\n').length > 15) {
-      console.log(pc.dim('...'));
+    // Get or perform scan
+    let scanResult = options.scanResult;
+    if (!scanResult) {
+      const scanner = new Scanner();
+      scanResult = await scanner.scan(projectRoot);
     }
-    console.log('');
 
-    const shouldCreate = await prompts.confirm({
-      message: 'Create this spec file?',
-      initialValue: true,
+    const specGenerator = new SpecGenerator({
+      featureName: feature,
+      projectRoot,
+      provider,
+      model,
+      scanResult,
     });
 
-    if (prompts.isCancel(shouldCreate) || !shouldCreate) {
-      logger.info('Cancelled');
+    const generatedSpec = await specGenerator.run();
+
+    if (!generatedSpec) {
+      logger.info('Spec generation cancelled');
       return;
     }
+
+    specContent = generatedSpec;
+
+    // Confirm saving (unless --yes)
+    if (!options.yes) {
+      console.log('');
+      const shouldSave = await prompts.confirm({
+        message: `Save spec to ${specPath}?`,
+        initialValue: true,
+      });
+
+      if (prompts.isCancel(shouldSave) || !shouldSave) {
+        logger.info('Spec not saved');
+        return;
+      }
+    }
+  } else {
+    // Use template-based generation
+    if (options.ai && !provider) {
+      logger.warn('No API key found. Falling back to template mode.');
+      logger.info('Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or OPENROUTER_API_KEY for AI generation.');
+      console.log('');
+    }
+
+    // Find or use default template
+    let templateContent: string;
+
+    // Try to find _example.md template
+    const exampleTemplate = await findExampleTemplate(projectRoot);
+    if (exampleTemplate) {
+      logger.info(`Using template: ${exampleTemplate}`);
+      templateContent = readFileSync(exampleTemplate, 'utf-8');
+    } else {
+      // Try package template
+      const packageTemplateDir = getPackageTemplateDir();
+      const packageTemplate = join(packageTemplateDir, '_example.md.tmpl');
+      if (existsSync(packageTemplate)) {
+        logger.info(`Using package template`);
+        templateContent = readFileSync(packageTemplate, 'utf-8');
+      } else {
+        // Use default template
+        logger.info('Using default template');
+        templateContent = DEFAULT_SPEC_TEMPLATE;
+      }
+    }
+
+    // Process template
+    specContent = processTemplate(templateContent, feature);
+
+    // Confirm with user (unless --yes)
+    if (!options.yes) {
+      console.log('');
+      console.log(pc.cyan('--- Spec Preview ---'));
+      console.log(`File: ${specPath}`);
+      console.log('');
+
+      // Show first few lines of the processed template
+      const previewLines = specContent.split('\n').slice(0, 15);
+      console.log(pc.dim(previewLines.join('\n')));
+      if (specContent.split('\n').length > 15) {
+        console.log(pc.dim('...'));
+      }
+      console.log('');
+
+      const shouldCreate = await prompts.confirm({
+        message: 'Create this spec file?',
+        initialValue: true,
+      });
+
+      if (prompts.isCancel(shouldCreate) || !shouldCreate) {
+        logger.info('Cancelled');
+        return;
+      }
+    }
   }
 
   // Write the spec file
@@ -308,5 +385,5 @@ export async function newCommand(feature: string, options: NewOptions = {}): Pro
   console.log('');
   console.log('Next steps:');
   console.log(`  1. Edit the spec: ${pc.cyan(`$EDITOR ${specPath}`)}`);
-  console.log(`  2. When ready, run: ${pc.cyan(`ralph run ${feature}`)}`);
+  console.log(`  2. When ready, run: ${pc.cyan(`wiggum run ${feature}`)}`);
 }

package/src/commands/run.ts

@@ -94,7 +94,7 @@ export async function runCommand(feature: string, options: RunOptions = {}): Pro
 
   // Check for config
   if (!hasConfig(projectRoot)) {
-    logger.warn('No ralph.config.js found. Run "ralph init" first to configure your project.');
+    logger.warn('No ralph.config.cjs found. Run "wiggum init" first to configure your project.');
     logger.info('Attempting to run with default settings...');
     console.log('');
   }
@@ -106,7 +106,7 @@ export async function runCommand(feature: string, options: RunOptions = {}): Pro
   const specFile = await validateSpecFile(projectRoot, feature);
   if (!specFile) {
     logger.error(`Spec file not found: ${feature}.md`);
-    logger.info(`Create the spec first: ralph new ${feature}`);
+    logger.info(`Create the spec first: wiggum new ${feature}`);
     logger.info(`Expected location: ${join(projectRoot, config.paths.specs, `${feature}.md`)}`);
     process.exit(1);
   }
@@ -118,7 +118,7 @@ export async function runCommand(feature: string, options: RunOptions = {}): Pro
   if (!scriptPath) {
     logger.error('feature-loop.sh script not found');
     logger.info('The script should be in .ralph/scripts/ or the ralph/ directory');
-    logger.info('Run "ralph init" to generate the necessary scripts');
+    logger.info('Run "wiggum init" to generate the necessary scripts');
     process.exit(1);
   }
 

package/src/generator/config.ts

@@ -1,6 +1,6 @@
 /**
  * Config Generator
- * Generates ralph.config.js file from scan results
+ * Generates ralph.config.cjs file from scan results
  */
 
 import type { ScanResult } from '../scanner/types.js';
@@ -95,9 +95,11 @@ export function generateConfig(scanResult: ScanResult, customVars: Record<string
 }
 
 /**
- * Generate ralph.config.js file content as JavaScript module
+ * Generate ralph.config.cjs file content as CommonJS module
  */
 export function generateConfigFile(config: RalphConfig): string {
+  // Use CommonJS module.exports for compatibility with both CJS and ESM projects
+  // ESM projects can import CJS modules, but CJS projects can't use 'export default'
   const content = `module.exports = ${JSON.stringify(config, null, 2)};
 `;
 
@@ -108,7 +110,7 @@ export function generateConfigFile(config: RalphConfig): string {
 }
 
 /**
- * Generate ralph.config.js from scan result
+ * Generate ralph.config.cjs from scan result
  */
 export function generateConfigFileFromScan(scanResult: ScanResult, customVars: Record<string, string> = {}): string {
   const config = generateConfig(scanResult, customVars);

package/src/generator/index.ts

@@ -128,7 +128,7 @@ export class Generator {
     if (this.options.generateConfig) {
       config = generateConfig(scanResult, this.options.customVariables || {});
       const configContent = generateConfigFile(config);
-      processedTemplates.set('config/ralph.config.js', configContent);
+      processedTemplates.set('config/ralph.config.cjs', configContent);
     }
 
     // Map template outputs to final paths

package/src/generator/writer.ts

@@ -242,7 +242,7 @@ export function mapTemplateOutputPaths(templateOutputs: Map<string, string>): Ma
       // Scripts go to .ralph/scripts/
       finalPath = `.ralph/${outputPath}`;
     } else if (outputPath.startsWith('config/')) {
-      // ralph.config.js goes to project root
+      // ralph.config.cjs goes to project root
       finalPath = outputPath.replace('config/', '');
     } else if (outputPath.startsWith('root/')) {
       // Root files go to .ralph/

package/src/index.ts

@@ -1,9 +1,55 @@
 import { createCli } from './cli.js';
+import { startRepl, createSessionState } from './repl/index.js';
+import { hasConfig, loadConfigWithDefaults } from './utils/config.js';
+import { getAvailableProvider } from './ai/providers.js';
+import { displayHeader } from './utils/header.js';
+
+/**
+ * Start REPL-first mode
+ * Called when wiggum is invoked with no arguments
+ */
+async function startReplFirst(): Promise<void> {
+  const projectRoot = process.cwd();
+  const provider = getAvailableProvider();
+
+  // Display header
+  displayHeader();
+
+  // Check if already initialized
+  const isInitialized = hasConfig(projectRoot);
+  let config = null;
+
+  if (isInitialized) {
+    config = await loadConfigWithDefaults(projectRoot);
+  }
+
+  // Create initial state (may not have config yet)
+  const initialState = createSessionState(
+    projectRoot,
+    provider, // May be null if no API key
+    'sonnet', // Default model, will be updated after /init
+    undefined, // No scan result yet
+    config,
+    isInitialized
+  );
+
+  await startRepl(initialState);
+}
 
 /**
  * Main entry point for the Ralph CLI
+ * REPL-first: no args = start REPL, otherwise use CLI
  */
 export async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  // REPL-first: no args = start REPL
+  if (args.length === 0) {
+    await startReplFirst();
+    return;
+  }
+
+  // Legacy CLI mode for backward compatibility
   const program = createCli();
   await program.parseAsync(process.argv);
 }

package/src/repl/command-parser.ts

@@ -0,0 +1,154 @@
+/**
+ * Command Parser
+ * Parses slash commands and natural language input for the REPL
+ */
+
+/**
+ * Parsed slash command
+ */
+export interface SlashCommand {
+  /** Command name (without slash) */
+  name: string;
+  /** Command arguments */
+  args: string[];
+  /** Raw input string */
+  raw: string;
+}
+
+/**
+ * Input types
+ */
+export type InputType = 'slash-command' | 'natural-language' | 'empty';
+
+/**
+ * Parsed input result
+ */
+export interface ParsedInput {
+  type: InputType;
+  command?: SlashCommand;
+  text?: string;
+}
+
+/**
+ * Available REPL commands
+ */
+export const REPL_COMMANDS = {
+  init: {
+    description: 'Initialize Wiggum in this project',
+    usage: '/init',
+    aliases: ['i'],
+  },
+  new: {
+    description: 'Create a new feature specification',
+    usage: '/new <feature-name>',
+    aliases: ['n'],
+  },
+  run: {
+    description: 'Run the feature development loop',
+    usage: '/run <feature-name>',
+    aliases: ['r'],
+  },
+  monitor: {
+    description: 'Monitor a running feature loop',
+    usage: '/monitor <feature-name>',
+    aliases: ['m'],
+  },
+  help: {
+    description: 'Show available commands',
+    usage: '/help',
+    aliases: ['h', '?'],
+  },
+  exit: {
+    description: 'Exit the REPL',
+    usage: '/exit',
+    aliases: ['quit', 'q'],
+  },
+} as const;
+
+export type ReplCommandName = keyof typeof REPL_COMMANDS;
+
+/**
+ * Check if input is a slash command
+ */
+export function isSlashCommand(input: string): boolean {
+  return input.trim().startsWith('/');
+}
+
+/**
+ * Parse a slash command from input
+ */
+export function parseSlashCommand(input: string): SlashCommand {
+  const trimmed = input.trim();
+  const parts = trimmed.slice(1).split(/\s+/);
+
+  return {
+    name: parts[0]?.toLowerCase() || '',
+    args: parts.slice(1),
+    raw: input,
+  };
+}
+
+/**
+ * Resolve command aliases to canonical command names
+ */
+export function resolveCommandAlias(name: string): ReplCommandName | null {
+  // Check direct match
+  if (name in REPL_COMMANDS) {
+    return name as ReplCommandName;
+  }
+
+  // Check aliases
+  for (const [cmdName, cmdDef] of Object.entries(REPL_COMMANDS)) {
+    if ((cmdDef.aliases as readonly string[]).includes(name)) {
+      return cmdName as ReplCommandName;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Parse user input into structured format
+ */
+export function parseInput(input: string): ParsedInput {
+  const trimmed = input.trim();
+
+  if (!trimmed) {
+    return { type: 'empty' };
+  }
+
+  if (isSlashCommand(trimmed)) {
+    return {
+      type: 'slash-command',
+      command: parseSlashCommand(trimmed),
+    };
+  }
+
+  return {
+    type: 'natural-language',
+    text: trimmed,
+  };
+}
+
+/**
+ * Format help text for all commands
+ */
+export function formatHelpText(): string {
+  const lines: string[] = [
+    'Available commands:',
+    '',
+  ];
+
+  for (const [name, def] of Object.entries(REPL_COMMANDS)) {
+    const aliases = def.aliases.length > 0
+      ? ` (aliases: ${def.aliases.map(a => '/' + a).join(', ')})`
+      : '';
+    lines.push(`  ${def.usage}${aliases}`);
+    lines.push(`    ${def.description}`);
+    lines.push('');
+  }
+
+  lines.push('Or just type naturally to chat with the AI.');
+
+  return lines.join('\n');
+}

package/src/repl/index.ts

@@ -0,0 +1,23 @@
+/**
+ * REPL Module
+ * Interactive command-line interface for Wiggum
+ */
+
+export { startRepl, processInput, executeCommand } from './repl-loop.js';
+export {
+  type SessionState,
+  createSessionState,
+  updateSessionState,
+} from './session-state.js';
+export {
+  type SlashCommand,
+  type ParsedInput,
+  type InputType,
+  type ReplCommandName,
+  parseInput,
+  parseSlashCommand,
+  isSlashCommand,
+  resolveCommandAlias,
+  formatHelpText,
+  REPL_COMMANDS,
+} from './command-parser.js';