wiggum-cli 0.7.3 → 0.7.5

package/src/ai/conversation/spec-generator.ts

@@ -1,19 +1,42 @@
 /**
  * Spec Generator
  * AI-powered feature specification generator with interview flow
+ * Enhanced with codebase tools and Claude Code-like UX
  */
 
 import readline from 'node:readline';
 import pc from 'picocolors';
 import { ConversationManager } from './conversation-manager.js';
-import { fetchContent, isUrl, type FetchedContent } from './url-fetcher.js';
+import { fetchContent } from './url-fetcher.js';
+import { createInterviewTools } from './interview-tools.js';
+import { createTavilySearchTool, canUseTavily } from '../tools/tavily.js';
+import { createContext7Tools, canUseContext7 } from '../tools/context7.js';
 import type { AIProvider } from '../providers.js';
 import type { ScanResult } from '../../scanner/types.js';
+import type { EnhancedScanResult, AIAnalysisResult } from '../enhancer.js';
 import { simpson } from '../../utils/colors.js';
+import {
+  displayPhaseHeader,
+  displayToolUse,
+  displaySessionContext,
+  displayGarbledInputWarning,
+  type Phase,
+} from '../../utils/tui.js';
 
 /** Maximum number of interview questions before auto-completing */
 const MAX_INTERVIEW_QUESTIONS = 10;
 
+/**
+ * Session context from /init analysis
+ */
+export interface SessionContext {
+  entryPoints?: string[];
+  keyDirectories?: Record<string, string>;
+  commands?: { build?: string; dev?: string; test?: string };
+  namingConventions?: string;
+  implementationGuidelines?: string[];
+}
+
 /**
  * Spec generator options
  */
@@ -23,6 +46,12 @@ export interface SpecGeneratorOptions {
   provider: AIProvider;
   model: string;
   scanResult?: ScanResult;
+  /** Rich session context from /init */
+  sessionContext?: SessionContext;
+  /** Tavily API key for web search */
+  tavilyApiKey?: string;
+  /** Context7 API key for docs lookup */
+  context7ApiKey?: string;
 }
 
 /**
@@ -48,9 +77,10 @@ async function promptUser(prompt: string): Promise<string> {
 }
 
 /**
- * Display streaming text
+ * Display streaming text with AI prefix
  */
 async function displayStream(stream: AsyncIterable<string>): Promise<string> {
+  process.stdout.write(simpson.blue('AI: '));
   let fullText = '';
   for await (const chunk of stream) {
     process.stdout.write(chunk);
@@ -60,7 +90,39 @@ async function displayStream(stream: AsyncIterable<string>): Promise<string> {
   return fullText;
 }
 
-const SPEC_SYSTEM_PROMPT = `You are an expert product manager and technical writer helping to create detailed feature specifications.
+/**
+ * Check if input looks garbled (common paste issues)
+ */
+function looksGarbled(input: string): boolean {
+  const trimmed = input.trim();
+
+  // Too short to be meaningful
+  if (trimmed.length < 3) return false;
+
+  // Common patterns from truncated pastes
+  const garbledPatterns = [
+    /^[a-z]+';$/i,           // Just "js';" or "ts';"
+    /^[,\.\;\{\}\[\]]+$/,    // Just punctuation
+    /^\s*['"`]\s*$/,         // Just quotes
+    /^[a-z]{1,3}$/i,         // Just 1-3 letters
+    /^\d+$/,                 // Just numbers
+    /^[^\w\s]+$/,            // Only special characters
+  ];
+
+  return garbledPatterns.some(p => p.test(trimmed));
+}
+
+/**
+ * Build enhanced system prompt with project context and tool awareness
+ */
+function buildSystemPrompt(
+  sessionContext?: SessionContext,
+  hasTools?: { codebase: boolean; tavily: boolean; context7: boolean }
+): string {
+  const parts: string[] = [];
+
+  // Base prompt
+  parts.push(`You are an expert product manager and technical writer helping to create detailed feature specifications.
 
 Your role is to:
 1. Understand the user's feature goals through targeted questions
@@ -71,8 +133,82 @@ When interviewing:
 - Ask one focused question at a time
 - Acknowledge answers before asking the next question
 - Stop asking when you have enough information (usually 3-5 questions)
-- Say "I have enough information to generate the spec" when ready
+- Say "I have enough information to generate the spec" when ready`);
+
+  // Add tool awareness
+  if (hasTools) {
+    const toolList: string[] = [];
+    if (hasTools.codebase) {
+      toolList.push('- read_file: Read project files to understand existing code');
+      toolList.push('- search_codebase: Search for patterns, functions, or imports');
+      toolList.push('- list_directory: Explore project structure');
+    }
+    if (hasTools.tavily) {
+      toolList.push('- tavily_search: Search the web for best practices and documentation');
+    }
+    if (hasTools.context7) {
+      toolList.push('- resolveLibraryId/queryDocs: Look up library documentation');
+    }
+
+    if (toolList.length > 0) {
+      parts.push(`
+## Available Tools
+You have access to the following tools to help understand the project and gather information:
+${toolList.join('\n')}
+
+USE THESE TOOLS PROACTIVELY:
+- When the user describes a feature, read relevant files to understand existing patterns
+- When unsure about implementation, search the codebase for similar code
+- When discussing best practices, search the web for current recommendations
+- Don't ask the user to paste code - read it yourself`);
+    }
+  }
+
+  // Add project context from /init
+  if (sessionContext) {
+    const contextParts: string[] = ['## Project Context (from analysis)'];
+
+    if (sessionContext.entryPoints && sessionContext.entryPoints.length > 0) {
+      contextParts.push(`\nEntry Points:\n${sessionContext.entryPoints.map(e => `- ${e}`).join('\n')}`);
+    }
+
+    if (sessionContext.keyDirectories && Object.keys(sessionContext.keyDirectories).length > 0) {
+      contextParts.push(`\nKey Directories:`);
+      for (const [dir, purpose] of Object.entries(sessionContext.keyDirectories)) {
+        contextParts.push(`- ${dir}: ${purpose}`);
+      }
+    }
 
+    if (sessionContext.commands) {
+      const cmds = sessionContext.commands;
+      const cmdList = Object.entries(cmds).filter(([_, v]) => v);
+      if (cmdList.length > 0) {
+        contextParts.push(`\nCommands:`);
+        for (const [name, cmd] of cmdList) {
+          contextParts.push(`- ${name}: ${cmd}`);
+        }
+      }
+    }
+
+    if (sessionContext.namingConventions) {
+      contextParts.push(`\nNaming Conventions: ${sessionContext.namingConventions}`);
+    }
+
+    if (sessionContext.implementationGuidelines && sessionContext.implementationGuidelines.length > 0) {
+      contextParts.push(`\nImplementation Guidelines:`);
+      for (const guideline of sessionContext.implementationGuidelines) {
+        contextParts.push(`- ${guideline}`);
+      }
+    }
+
+    if (contextParts.length > 1) {
+      parts.push(contextParts.join('\n'));
+    }
+  }
+
+  // Spec format
+  parts.push(`
+## Spec Format
 When generating the spec, use this format:
 
 # [Feature Name] Feature Specification
@@ -104,8 +240,30 @@ When generating the spec, use this format:
 - [ ] Specific, testable conditions
 
 ## Out of Scope
-- Items explicitly not included
-`;
+- Items explicitly not included`);
+
+  return parts.join('\n\n');
+}
+
+/**
+ * Extract session context from EnhancedScanResult
+ */
+function extractSessionContext(scanResult: ScanResult): SessionContext | undefined {
+  // Check if this is an EnhancedScanResult with aiAnalysis
+  const enhanced = scanResult as EnhancedScanResult;
+  if (!enhanced.aiAnalysis) {
+    return undefined;
+  }
+
+  const ai = enhanced.aiAnalysis;
+  return {
+    entryPoints: ai.projectContext?.entryPoints,
+    keyDirectories: ai.projectContext?.keyDirectories,
+    commands: ai.commands,
+    namingConventions: ai.projectContext?.namingConventions,
+    implementationGuidelines: ai.implementationGuidelines,
+  };
+}
 
 /**
  * AI-powered spec generator with interview flow
@@ -116,15 +274,61 @@ export class SpecGenerator {
   private readonly featureName: string;
   private readonly projectRoot: string;
   private generatedSpec: string = '';
+  private questionCount: number = 0;
+  private readonly hasTools: { codebase: boolean; tavily: boolean; context7: boolean };
+  private readonly sessionContext?: SessionContext;
 
   constructor(options: SpecGeneratorOptions) {
     this.featureName = options.featureName;
     this.projectRoot = options.projectRoot;
 
+    // Get API keys from options or environment
+    const tavilyApiKey = options.tavilyApiKey || process.env.TAVILY_API_KEY;
+    const context7ApiKey = options.context7ApiKey || process.env.CONTEXT7_API_KEY;
+
+    // Track which tools are available
+    this.hasTools = {
+      codebase: true, // Always available
+      tavily: canUseTavily(tavilyApiKey),
+      context7: canUseContext7(context7ApiKey),
+    };
+
+    // Build tools object
+    const tools: Record<string, unknown> = {};
+
+    // Add codebase tools
+    const codebaseTools = createInterviewTools(options.projectRoot);
+    Object.assign(tools, codebaseTools);
+
+    // Add Tavily search if available
+    if (this.hasTools.tavily && tavilyApiKey) {
+      tools.tavily_search = createTavilySearchTool(tavilyApiKey);
+    }
+
+    // Add Context7 tools if available
+    if (this.hasTools.context7 && context7ApiKey) {
+      const context7Tools = createContext7Tools(context7ApiKey);
+      Object.assign(tools, context7Tools);
+    }
+
+    // Extract session context from scan result or use provided
+    this.sessionContext = options.sessionContext || (
+      options.scanResult ? extractSessionContext(options.scanResult) : undefined
+    );
+
+    // Build enhanced system prompt
+    const systemPrompt = buildSystemPrompt(this.sessionContext, this.hasTools);
+
+    // Create conversation manager with tools
     this.conversation = new ConversationManager({
       provider: options.provider,
       model: options.model,
-      systemPrompt: SPEC_SYSTEM_PROMPT,
+      systemPrompt,
+      tools: tools as Record<string, never>,
+      onToolUse: (toolName, args) => {
+        displayToolUse(toolName, args);
+      },
+      maxToolSteps: 8,
     });
 
     if (options.scanResult) {
@@ -132,11 +336,37 @@ export class SpecGenerator {
     }
   }
 
+  /**
+   * Display the current phase header
+   */
+  private displayHeader(): void {
+    displayPhaseHeader(this.featureName, this.phase, {
+      current: this.questionCount,
+      max: MAX_INTERVIEW_QUESTIONS,
+    });
+  }
+
+  /**
+   * Display session context at start
+   */
+  private displayContext(): void {
+    // Build project name from package.json or directory
+    const projectName = this.projectRoot.split('/').pop() || 'Project';
+
+    displaySessionContext({
+      projectName,
+      entryPoints: this.sessionContext?.entryPoints,
+      tools: this.hasTools,
+    });
+  }
+
   /**
    * Phase 1: Gather context from URLs/files
    */
   private async gatherContext(): Promise<void> {
-    console.log('');
+    this.displayHeader();
+    this.displayContext();
+
     console.log(simpson.yellow('Context Gathering'));
     console.log(pc.dim('Share any reference URLs or files (press Enter to skip):'));
     console.log('');
@@ -148,7 +378,7 @@ export class SpecGenerator {
         break;
       }
 
-      process.stdout.write(pc.dim('Fetching... '));
+      process.stdout.write(pc.dim('    Fetching... '));
       const result = await fetchContent(input, this.projectRoot);
 
       if (result.error) {
@@ -166,7 +396,8 @@ export class SpecGenerator {
    * Phase 2: Discuss goals
    */
   private async discussGoals(): Promise<void> {
-    console.log('');
+    this.displayHeader();
+
     console.log(simpson.yellow('Feature Goals'));
     console.log(pc.dim('Describe what you want to build:'));
     console.log('');
@@ -188,9 +419,10 @@ export class SpecGenerator {
 
     console.log('');
     const response = await this.conversation.chat(
-      `The user wants to create a feature called "${this.featureName}". Acknowledge their goals and ask your first clarifying question to better understand the requirements.`
+      `The user wants to create a feature called "${this.featureName}". First, use your tools to explore the codebase and understand the existing structure. Then acknowledge their goals and ask your first clarifying question.`
     );
 
+    console.log('');
     console.log(simpson.blue('AI:'), response);
     console.log('');
 
@@ -201,19 +433,21 @@ export class SpecGenerator {
    * Phase 3: Conduct interview
    */
   private async conductInterview(): Promise<void> {
+    this.displayHeader();
+
     console.log(simpson.yellow('Interview'));
     console.log(pc.dim('Answer the questions (type "done" when ready to generate spec):'));
     console.log('');
 
-    let questionCount = 0;
-
-    while (questionCount < MAX_INTERVIEW_QUESTIONS) {
+    while (this.questionCount < MAX_INTERVIEW_QUESTIONS) {
       const answer = await promptUser(`${simpson.brown('you>')} `);
 
+      // Handle exit commands
       if (answer.toLowerCase() === 'done' || answer.toLowerCase() === 'skip') {
         break;
       }
 
+      // Handle empty input
       if (!answer) {
         console.log(pc.dim('(Press Enter again to skip, or type your answer)'));
         const confirm = await promptUser(`${simpson.brown('you>')} `);
@@ -221,38 +455,57 @@ export class SpecGenerator {
           break;
         }
         // Process the confirmation as the answer
-        console.log('');
-        const response = await this.conversation.chat(confirm);
-        console.log(simpson.blue('AI:'), response);
-        console.log('');
-      } else {
-        console.log('');
-        const response = await this.conversation.chat(answer);
-        console.log(simpson.blue('AI:'), response);
-        console.log('');
+        await this.processAnswer(confirm);
+        continue;
+      }
 
-        // Check if AI indicates it has enough information
-        if (
-          response.toLowerCase().includes('enough information') ||
-          response.toLowerCase().includes('ready to generate') ||
-          response.toLowerCase().includes("let me generate") ||
-          response.toLowerCase().includes("i'll now generate")
-        ) {
-          break;
-        }
+      // Check for garbled input
+      if (looksGarbled(answer)) {
+        displayGarbledInputWarning(answer);
+        continue;
       }
 
-      questionCount++;
+      // Process normal answer
+      const shouldBreak = await this.processAnswer(answer);
+      if (shouldBreak) break;
     }
 
     this.phase = 'generation';
   }
 
+  /**
+   * Process a user answer and get AI response
+   */
+  private async processAnswer(answer: string): Promise<boolean> {
+    console.log('');
+    const response = await this.conversation.chat(answer);
+    console.log('');
+    console.log(simpson.blue('AI:'), response);
+    console.log('');
+
+    this.questionCount++;
+
+    // Check if AI indicates it has enough information
+    const lowerResponse = response.toLowerCase();
+    if (
+      lowerResponse.includes('enough information') ||
+      lowerResponse.includes('ready to generate') ||
+      lowerResponse.includes("let me generate") ||
+      lowerResponse.includes("i'll now generate") ||
+      lowerResponse.includes("i will now generate")
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
   /**
    * Phase 4: Generate spec
    */
   private async generateSpec(): Promise<string> {
-    console.log('');
+    this.displayHeader();
+
     console.log(simpson.yellow('Generating Specification...'));
     console.log('');
 

package/src/commands/init.ts

@@ -18,7 +18,7 @@ import {
   getAvailableProvider,
   AVAILABLE_MODELS,
 } from '../ai/providers.js';
-import * as prompts from '@clack/prompts';
+import * as replPrompts from '../utils/repl-prompts.js';
 import fs from 'fs';
 import path from 'path';
 import {
@@ -33,23 +33,8 @@ import { createShimmerSpinner, type ShimmerSpinner } from '../utils/spinner.js';
 import { startRepl, createSessionState } from '../repl/index.js';
 import { loadConfigWithDefaults } from '../utils/config.js';
 
-/**
- * Secure password input using @clack/prompts
- * Works correctly in both CLI and REPL contexts
- */
-async function securePasswordInput(message: string): Promise<string | null> {
-  const result = await prompts.password({
-    message,
-    mask: '*',
-  });
-
-  if (prompts.isCancel(result)) {
-    return null;
-  }
-
-  // Return trimmed input, filtering any control characters
-  return (result as string).trim().replace(/[\x00-\x1F\x7F]/g, '') || null;
-}
+// Use REPL-friendly prompts for interactive input
+const prompts = replPrompts;
 
 export interface InitOptions {
   provider?: AIProvider;
@@ -154,8 +139,10 @@ async function collectApiKeys(
     provider = providerChoice as AIProvider;
     const envVar = getApiKeyEnvVar(provider);
 
-    // Get API key with fixed-length mask (doesn't reveal key length)
-    const apiKeyInput = await securePasswordInput(`Enter your ${envVar}:`);
+    // Get API key with masked input
+    const apiKeyInput = await prompts.password({
+      message: `Enter your ${envVar}:`,
+    });
 
     if (!apiKeyInput) {
       logger.error('API key is required to use Ralph.');
@@ -382,12 +369,13 @@ export async function runInitWorkflow(
       logger.success('Wiggum initialized successfully!');
 
       // Load config and return result
+      // Use enhancedResult to preserve aiAnalysis for session context
       const config = await loadConfigWithDefaults(projectRoot);
       return {
         success: true,
         provider: apiKeys.provider,
         model: apiKeys.model,
-        scanResult,
+        scanResult: enhancedResult,
         config,
       };
     } else {
@@ -397,7 +385,7 @@ export async function runInitWorkflow(
         success: true, // Still return success to continue
         provider: apiKeys.provider,
         model: apiKeys.model,
-        scanResult,
+        scanResult: enhancedResult,
         config,
       };
     }