wiggum-cli 0.5.4 → 0.7.0

package/src/ai/conversation/url-fetcher.ts

@@ -0,0 +1,180 @@
+/**
+ * URL Fetcher
+ * Fetches content from URLs and local files for context gathering
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, isAbsolute } from 'node:path';
+
+const MAX_CONTENT_LENGTH = 10000;
+const FETCH_TIMEOUT = 10000;
+
+/**
+ * Fetched content result
+ */
+export interface FetchedContent {
+  source: string;
+  content: string;
+  truncated: boolean;
+  error?: string;
+}
+
+/**
+ * Check if a string is a URL
+ */
+export function isUrl(input: string): boolean {
+  try {
+    const url = new URL(input);
+    return url.protocol === 'http:' || url.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Extract text content from HTML
+ * Simple extraction that removes scripts, styles, and HTML tags
+ */
+function extractTextFromHtml(html: string): string {
+  // Remove script and style tags with their content
+  let text = html
+    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+    .replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, '');
+
+  // Remove HTML tags but keep content
+  text = text.replace(/<[^>]+>/g, ' ');
+
+  // Decode common HTML entities
+  text = text
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
+
+  // Clean up whitespace
+  text = text.replace(/\s+/g, ' ').trim();
+
+  return text;
+}
+
+/**
+ * Fetch content from a URL
+ */
+async function fetchFromUrl(url: string): Promise<FetchedContent> {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        'User-Agent': 'Wiggum-CLI/1.0 (Feature Spec Generator)',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7',
+      },
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      return {
+        source: url,
+        content: '',
+        truncated: false,
+        error: `HTTP ${response.status}: ${response.statusText}`,
+      };
+    }
+
+    const contentType = response.headers.get('content-type') || '';
+    let text = await response.text();
+
+    // If HTML, extract text content
+    if (contentType.includes('text/html')) {
+      text = extractTextFromHtml(text);
+    }
+
+    // Truncate if too long
+    const truncated = text.length > MAX_CONTENT_LENGTH;
+    if (truncated) {
+      text = text.slice(0, MAX_CONTENT_LENGTH) + '\n\n[Content truncated...]';
+    }
+
+    return {
+      source: url,
+      content: text,
+      truncated,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      source: url,
+      content: '',
+      truncated: false,
+      error: errorMessage.includes('abort') ? 'Request timed out' : errorMessage,
+    };
+  }
+}
+
+/**
+ * Read content from a local file
+ */
+function readFromFile(filePath: string, projectRoot: string): FetchedContent {
+  try {
+    const absolutePath = isAbsolute(filePath) ? filePath : resolve(projectRoot, filePath);
+
+    if (!existsSync(absolutePath)) {
+      return {
+        source: filePath,
+        content: '',
+        truncated: false,
+        error: 'File not found',
+      };
+    }
+
+    let content = readFileSync(absolutePath, 'utf-8');
+
+    // Truncate if too long
+    const truncated = content.length > MAX_CONTENT_LENGTH;
+    if (truncated) {
+      content = content.slice(0, MAX_CONTENT_LENGTH) + '\n\n[Content truncated...]';
+    }
+
+    return {
+      source: filePath,
+      content,
+      truncated,
+    };
+  } catch (error) {
+    return {
+      source: filePath,
+      content: '',
+      truncated: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * Fetch content from a URL or local file path
+ */
+export async function fetchContent(
+  input: string,
+  projectRoot: string
+): Promise<FetchedContent> {
+  if (isUrl(input)) {
+    return fetchFromUrl(input);
+  }
+  return readFromFile(input, projectRoot);
+}
+
+/**
+ * Fetch multiple sources in parallel
+ */
+export async function fetchMultipleSources(
+  inputs: string[],
+  projectRoot: string
+): Promise<FetchedContent[]> {
+  return Promise.all(inputs.map(input => fetchContent(input, projectRoot)));
+}

package/src/cli.ts

@@ -13,7 +13,7 @@ export function createCli(): Command {
   const program = new Command();
 
   program
-    .name('ralph')
+    .name('wiggum')
     .description(
       'AI-powered feature development loop CLI.\n\n' +
         'Ralph auto-detects your tech stack and generates an intelligent\n' +
@@ -27,17 +27,17 @@ export function createCli(): Command {
       'after',
       `
 Examples:
-  $ ralph init                    Initialize Ralph with AI analysis
-  $ ralph new my-feature          Create a new feature specification
-  $ ralph run my-feature          Run the feature development loop
-  $ ralph monitor my-feature      Monitor progress in real-time
+  $ 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/ralph-cli#readme
+  https://github.com/your-org/wiggum-cli#readme
 `
     );
 
-  // ralph init
+  // wiggum init
   program
     .command('init')
     .description(
@@ -51,13 +51,15 @@ Documentation:
       'anthropic'
     )
     .option('-y, --yes', 'Accept defaults and skip all confirmation prompts')
+    .option('-i, --interactive', 'Stay in interactive REPL mode after initialization')
     .addHelpText(
       'after',
       `
 Examples:
-  $ ralph init                           Initialize with AI analysis
-  $ ralph init --provider openai         Use OpenAI provider
-  $ ralph init --yes                     Non-interactive mode
+  $ 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):
@@ -78,7 +80,7 @@ API Keys (BYOK - Bring Your Own Keys):
       }
     });
 
-  // ralph run <feature>
+  // wiggum run <feature>
   program
     .command('run <feature>')
     .description(
@@ -112,14 +114,14 @@ API Keys (BYOK - Bring Your Own Keys):
       'after',
       `
 Examples:
-  $ ralph run user-auth                     Run the user-auth feature
-  $ ralph run payment --worktree            Run in isolated worktree
-  $ ralph run payment --resume              Resume interrupted session
-  $ ralph run my-feature --model opus       Use Claude Opus model
-  $ ralph run my-feature --max-iterations 30 --max-e2e-attempts 5
+  $ 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: ralph new <feature>
+  - 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
 `
@@ -139,7 +141,7 @@ Notes:
       }
     });
 
-  // ralph monitor <feature>
+  // wiggum monitor <feature>
   program
     .command('monitor <feature>')
     .description(
@@ -162,9 +164,9 @@ Notes:
       'after',
       `
 Examples:
-  $ ralph monitor my-feature              Monitor with built-in dashboard
-  $ ralph monitor my-feature --interval 2 Refresh every 2 seconds
-  $ ralph monitor my-feature --bash       Use bash script monitor
+  $ 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.)
@@ -187,7 +189,7 @@ Dashboard Shows:
       }
     });
 
-  // ralph new <feature>
+  // wiggum new <feature>
   program
     .command('new <feature>')
     .description(
@@ -202,26 +204,34 @@ Dashboard Shows:
     )
     .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(
+      '--provider <name>',
+      'AI provider for spec generation (anthropic, openai, openrouter)'
+    )
+    .option('--model <model>', 'Model to use for AI spec generation')
     .addHelpText(
       'after',
       `
 Examples:
-  $ ralph new user-dashboard              Create spec with prompts
-  $ ralph new user-dashboard --edit       Create and open in editor
-  $ ralph new user-dashboard -e --editor vim  Open in vim
-  $ ralph new user-dashboard --yes        Skip confirmations
-  $ ralph new user-dashboard --force      Overwrite if exists
+  $ wiggum new user-dashboard              Create spec from template
+  $ wiggum new user-dashboard --ai         Use AI interview to generate spec
+  $ 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
 
-Template includes sections for:
-  - Purpose and user stories
-  - Functional and non-functional requirements
-  - Technical notes and dependencies
-  - Visual requirements (for UI features)
-  - API endpoints
-  - Acceptance criteria
+AI Mode (--ai):
+  - Gathers context from URLs/files you provide
+  - Conducts an interview to understand your requirements
+  - Generates a detailed, project-specific specification
+
+Template Mode (default):
+  - Uses a standard template with sections for:
+    Purpose, user stories, requirements, technical notes, etc.
 `
     )
     .action(async (feature: string, options) => {
@@ -231,6 +241,9 @@ Template includes sections for:
           editor: options.editor,
           yes: options.yes,
           force: options.force,
+          ai: options.ai,
+          provider: options.provider,
+          model: options.model,
         };
         await newCommand(feature, newOptions);
       } catch (error) {

package/src/commands/init.ts

@@ -31,6 +31,8 @@ import {
 } from '../utils/colors.js';
 import { flushTracing } from '../utils/tracing.js';
 import { createShimmerSpinner, type ShimmerSpinner } from '../utils/spinner.js';
+import { startRepl, createSessionState } from '../repl/index.js';
+import { loadConfigWithDefaults } from '../utils/config.js';
 
 const FIXED_MASK = '*'.repeat(32);
 
@@ -116,6 +118,18 @@ async function securePasswordInput(message: string): Promise<string | null> {
 export interface InitOptions {
   provider?: AIProvider;
   yes?: boolean;
+  interactive?: boolean;
+}
+
+/**
+ * Result of the init workflow
+ */
+export interface InitResult {
+  success: boolean;
+  provider: AIProvider;
+  model: string;
+  scanResult: ScanResult;
+  config: import('../utils/config.js').RalphConfig | null;
 }
 
 /**
@@ -275,12 +289,15 @@ async function collectApiKeys(
 }
 
 /**
- * Initialize Ralph in the current project
- * Uses BYOK (Bring Your Own Keys) model with multi-agent AI analysis
+ * Run the init workflow
+ * Reusable core logic for both CLI and REPL usage
+ * Returns InitResult on success, null on cancellation
+ * Throws on hard errors
  */
-export async function initCommand(options: InitOptions): Promise<void> {
-  const projectRoot = process.cwd();
-
+export async function runInitWorkflow(
+  projectRoot: string,
+  options: InitOptions
+): Promise<InitResult | null> {
   logger.info('Initializing Ralph...');
   logger.info(`Project: ${projectRoot}`);
   console.log('');
@@ -297,9 +314,8 @@ export async function initCommand(options: InitOptions): Promise<void> {
     scanSpinner.stop('Project scanned');
   } catch (error) {
     scanSpinner.fail('Scan failed');
-    logger.error(`Failed to scan project: ${error instanceof Error ? error.message : String(error)}`);
     await flushTracing();
-    process.exit(1);
+    throw new Error(`Failed to scan project: ${error instanceof Error ? error.message : String(error)}`);
   }
 
   // Step 2: Show detected stack
@@ -317,14 +333,9 @@ export async function initCommand(options: InitOptions): Promise<void> {
   const apiKeys = await collectApiKeys(projectRoot, options);
 
   if (!apiKeys) {
-    // In --yes mode, null means missing API key (hard failure)
-    // In interactive mode, null means user cancelled
+    // User cancelled or missing API key in --yes mode
     await flushTracing();
-    if (options.yes) {
-      process.exit(1);
-    }
-    logger.info('Initialization cancelled');
-    return;
+    return null;
   }
 
   // Step 4: Run AI analysis
@@ -387,8 +398,7 @@ export async function initCommand(options: InitOptions): Promise<void> {
 
     if (prompts.isCancel(shouldContinue) || !shouldContinue) {
       await flushTracing();
-      logger.info('Initialization cancelled');
-      return;
+      return null;
     }
   }
 
@@ -424,23 +434,77 @@ export async function initCommand(options: InitOptions): Promise<void> {
     await flushTracing();
 
     if (generationResult.success) {
-      // Show next steps
+      // Show next steps (REPL-aware)
       console.log(nextStepsBox([
-        { command: 'ralph new my-feature', description: 'Create a feature specification' },
-        { command: 'ralph run my-feature', description: 'Start the development loop' },
-        { command: 'ralph monitor my-feature', description: 'Watch progress in real-time' },
+        { command: '/new my-feature', description: 'Create a feature specification' },
+        { command: '/run my-feature', description: 'Start the development loop' },
+        { command: '/help', description: 'Show all available commands' },
       ]));
 
       console.log(`  ${simpson.brown('Documentation:')} .ralph/guides/AGENTS.md`);
       console.log('');
-      logger.success('Ralph initialized successfully!');
+      logger.success('Wiggum initialized successfully!');
+
+      // Load config and return result
+      const config = await loadConfigWithDefaults(projectRoot);
+      return {
+        success: true,
+        provider: apiKeys.provider,
+        model: apiKeys.model,
+        scanResult,
+        config,
+      };
     } else {
       logger.warn('Initialization completed with some errors');
+      const config = await loadConfigWithDefaults(projectRoot);
+      return {
+        success: true, // Still return success to continue
+        provider: apiKeys.provider,
+        model: apiKeys.model,
+        scanResult,
+        config,
+      };
     }
   } catch (error) {
     genSpinner.fail('Generation failed');
-    logger.error(`Failed to generate files: ${error instanceof Error ? error.message : String(error)}`);
     await flushTracing();
+    throw new Error(`Failed to generate files: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Initialize Ralph in the current project
+ * Uses BYOK (Bring Your Own Keys) model with multi-agent AI analysis
+ */
+export async function initCommand(options: InitOptions): Promise<void> {
+  const projectRoot = process.cwd();
+
+  try {
+    const result = await runInitWorkflow(projectRoot, options);
+
+    if (!result) {
+      // Cancelled by user or missing API key
+      if (options.yes) {
+        process.exit(1);
+      }
+      logger.info('Initialization cancelled');
+      return;
+    }
+
+    // Start interactive REPL if requested
+    if (options.interactive) {
+      const sessionState = createSessionState(
+        projectRoot,
+        result.provider,
+        result.model,
+        result.scanResult,
+        result.config,
+        true // initialized
+      );
+      await startRepl(sessionState);
+    }
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 }