codebakers 2.0.4 → 2.0.10

package/src/utils/nlp.ts

@@ -0,0 +1,312 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import Anthropic from '@anthropic-ai/sdk';
+import { Config } from '../utils/config.js';
+
+// ============================================================================
+// COMMAND MAPPING
+// ============================================================================
+
+interface ParsedCommand {
+  command: string;
+  args: string[];
+  confidence: number;
+  interpretation: string;
+}
+
+interface CommandOption {
+  value: string;
+  label: string;
+  description: string;
+}
+
+const COMMAND_PATTERNS: Record<string, { patterns: string[]; description: string }> = {
+  init: {
+    patterns: ['new project', 'create app', 'start project', 'initialize', 'new app', 'start building', 'create new'],
+    description: 'Create a new project',
+  },
+  build: {
+    patterns: ['build from prd', 'build app', 'build project', 'use prd', 'parallel build', 'swarm build', 'build this'],
+    description: 'Build from PRD with parallel agents',
+  },
+  code: {
+    patterns: ['add feature', 'create component', 'fix bug', 'help me code', 'write code', 'implement', 'add', 'create'],
+    description: 'AI coding agent',
+  },
+  check: {
+    patterns: ['check code', 'lint', 'validate', 'any problems', 'check quality', 'review code', 'check patterns'],
+    description: 'Check code quality and patterns',
+  },
+  deploy: {
+    patterns: ['deploy', 'publish', 'go live', 'push to production', 'ship it', 'release', 'launch'],
+    description: 'Deploy to Vercel',
+  },
+  fix: {
+    patterns: ['fix errors', 'fix bugs', 'repair', 'broken', 'not working', 'fix issues', 'auto fix'],
+    description: 'Auto-fix errors',
+  },
+  migrate: {
+    patterns: ['database', 'migration', 'schema', 'db push', 'migrate', 'update database'],
+    description: 'Database migrations',
+  },
+  design: {
+    patterns: ['design', 'colors', 'style', 'theme', 'branding', 'look and feel', 'ui style'],
+    description: 'Design system settings',
+  },
+  advisors: {
+    patterns: ['advisors', 'dream team', 'experts', 'feedback', 'review idea', 'consult', 'get advice'],
+    description: 'Dream Team advisory board',
+  },
+  'prd-maker': {
+    patterns: ['make prd', 'create prd', 'write requirements', 'plan project', 'document requirements', 'spec'],
+    description: 'Create PRD through interview',
+  },
+  security: {
+    patterns: ['security', 'vulnerabilities', 'audit', 'security check', 'scan for issues'],
+    description: 'Security audit',
+  },
+  status: {
+    patterns: ['status', 'progress', 'how is it going', 'show projects', 'list projects'],
+    description: 'Project status',
+  },
+  setup: {
+    patterns: ['setup', 'configure', 'connect accounts', 'api keys', 'settings'],
+    description: 'Initial setup',
+  },
+  help: {
+    patterns: ['help', 'what can you do', 'commands', 'how to use', 'guide'],
+    description: 'Show help',
+  },
+};
+
+// ============================================================================
+// NATURAL LANGUAGE PARSER
+// ============================================================================
+
+export async function parseNaturalLanguage(input: string, config: Config): Promise<ParsedCommand | null> {
+  const normalizedInput = input.toLowerCase().trim();
+  
+  // Quick pattern matching first (no API call needed)
+  const quickMatch = quickPatternMatch(normalizedInput);
+  if (quickMatch && quickMatch.confidence > 0.8) {
+    return quickMatch;
+  }
+
+  // For ambiguous or complex inputs, use Claude
+  const anthropicCreds = config.getCredentials('anthropic');
+  if (!anthropicCreds?.apiKey) {
+    // Fall back to best guess without AI
+    return quickMatch;
+  }
+
+  const anthropic = new Anthropic({ apiKey: anthropicCreds.apiKey });
+  
+  try {
+    const result = await parseWithAI(anthropic, input);
+    return result;
+  } catch {
+    // Fall back to pattern matching
+    return quickMatch;
+  }
+}
+
+function quickPatternMatch(input: string): ParsedCommand | null {
+  let bestMatch: ParsedCommand | null = null;
+  let highestScore = 0;
+
+  for (const [command, { patterns, description }] of Object.entries(COMMAND_PATTERNS)) {
+    for (const pattern of patterns) {
+      const score = calculateSimilarity(input, pattern);
+      if (score > highestScore) {
+        highestScore = score;
+        bestMatch = {
+          command,
+          args: extractArgs(input, pattern),
+          confidence: score,
+          interpretation: description,
+        };
+      }
+    }
+  }
+
+  // Check for direct command names
+  for (const command of Object.keys(COMMAND_PATTERNS)) {
+    if (input.includes(command)) {
+      return {
+        command,
+        args: extractArgs(input, command),
+        confidence: 0.95,
+        interpretation: COMMAND_PATTERNS[command].description,
+      };
+    }
+  }
+
+  return bestMatch;
+}
+
+function calculateSimilarity(input: string, pattern: string): number {
+  const inputWords = input.toLowerCase().split(/\s+/);
+  const patternWords = pattern.toLowerCase().split(/\s+/);
+  
+  let matches = 0;
+  for (const patternWord of patternWords) {
+    if (inputWords.some(w => w.includes(patternWord) || patternWord.includes(w))) {
+      matches++;
+    }
+  }
+  
+  return matches / patternWords.length;
+}
+
+function extractArgs(input: string, pattern: string): string[] {
+  // Remove the pattern words to get remaining args
+  const patternWords = pattern.toLowerCase().split(/\s+/);
+  const inputWords = input.split(/\s+/);
+  
+  const args = inputWords.filter(word => 
+    !patternWords.some(p => word.toLowerCase().includes(p) || p.includes(word.toLowerCase()))
+  );
+  
+  return args.filter(a => a.length > 2); // Filter out tiny words
+}
+
+async function parseWithAI(anthropic: Anthropic, input: string): Promise<ParsedCommand> {
+  const commandList = Object.entries(COMMAND_PATTERNS)
+    .map(([cmd, { description }]) => `- ${cmd}: ${description}`)
+    .join('\n');
+
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 500,
+    messages: [{
+      role: 'user',
+      content: `Parse this user input into a CLI command.
+
+User said: "${input}"
+
+Available commands:
+${commandList}
+- code: For any coding/feature request not matching above
+
+Return JSON only:
+{
+  "command": "command-name",
+  "args": ["any", "extracted", "arguments"],
+  "confidence": 0.95,
+  "interpretation": "What the user wants to do"
+}
+
+If the input is asking to build/create/add a specific feature, use "code" and put the request in args.
+If unclear between multiple commands, use the most likely one with lower confidence.`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+  const jsonMatch = text.match(/\{[\s\S]*?\}/);
+
+  if (!jsonMatch) {
+    // Default to code command for anything unclear
+    return {
+      command: 'code',
+      args: [input],
+      confidence: 0.5,
+      interpretation: 'Passing to AI coding agent',
+    };
+  }
+
+  return JSON.parse(jsonMatch[0]);
+}
+
+// ============================================================================
+// CLARIFICATION
+// ============================================================================
+
+export async function clarifyCommand(parsed: ParsedCommand): Promise<ParsedCommand> {
+  // If confidence is high enough, no clarification needed
+  if (parsed.confidence >= 0.8) {
+    return parsed;
+  }
+
+  // If confidence is medium, confirm
+  if (parsed.confidence >= 0.5) {
+    const confirm = await p.confirm({
+      message: `Did you mean: ${parsed.interpretation}?`,
+      initialValue: true,
+    });
+
+    if (confirm && !p.isCancel(confirm)) {
+      return { ...parsed, confidence: 1 };
+    }
+  }
+
+  // Low confidence or user said no - ask for clarification
+  const options: CommandOption[] = [
+    { value: 'init', label: '🆕 Create new project', description: 'Start a fresh project' },
+    { value: 'build', label: '🏗️  Build from PRD', description: 'Parallel build from document' },
+    { value: 'code', label: '💬 AI Coding', description: 'Get help writing code' },
+    { value: 'check', label: '🔍 Check code', description: 'Lint and validate' },
+    { value: 'deploy', label: '🚀 Deploy', description: 'Push to production' },
+    { value: 'fix', label: '🔧 Fix errors', description: 'Auto-fix issues' },
+    { value: 'advisors', label: '🌟 Dream Team', description: 'Get expert advice' },
+    { value: 'prd-maker', label: '📝 Create PRD', description: 'Document your idea' },
+    { value: 'other', label: '❓ Something else', description: 'Describe what you need' },
+  ];
+
+  const selection = await p.select({
+    message: 'What would you like to do?',
+    options: options.map(o => ({ value: o.value, label: o.label, hint: o.description })),
+  });
+
+  if (p.isCancel(selection)) {
+    return { ...parsed, command: 'cancel', confidence: 1 };
+  }
+
+  if (selection === 'other') {
+    const description = await p.text({
+      message: 'Describe what you want to do:',
+      placeholder: 'I want to...',
+    });
+
+    if (p.isCancel(description)) {
+      return { ...parsed, command: 'cancel', confidence: 1 };
+    }
+
+    // Pass to code agent as free-form request
+    return {
+      command: 'code',
+      args: [description as string],
+      confidence: 1,
+      interpretation: description as string,
+    };
+  }
+
+  return {
+    command: selection as string,
+    args: parsed.args,
+    confidence: 1,
+    interpretation: options.find(o => o.value === selection)?.description || '',
+  };
+}
+
+// ============================================================================
+// DEPLOY CLARIFICATION
+// ============================================================================
+
+export async function clarifyDeployTarget(): Promise<'preview' | 'production' | null> {
+  const target = await p.select({
+    message: 'Where do you want to deploy?',
+    options: [
+      { value: 'preview', label: '🔍 Preview', hint: 'Test URL to review changes' },
+      { value: 'production', label: '🚀 Production', hint: 'Live site for users' },
+    ],
+  });
+
+  if (p.isCancel(target)) return null;
+  return target as 'preview' | 'production';
+}
+
+// ============================================================================
+// EXPORTS
+// ============================================================================
+
+export { COMMAND_PATTERNS };

package/src/utils/voice.ts

@@ -0,0 +1,323 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import { execa } from 'execa';
+
+let voiceAvailable: boolean | null = null;
+
+export async function checkVoiceAvailability(): Promise<boolean> {
+  if (voiceAvailable !== null) return voiceAvailable;
+  
+  try {
+    if (process.platform === 'win32') {
+      // Windows always has PowerShell speech
+      voiceAvailable = true;
+    } else if (process.platform === 'darwin') {
+      // macOS - check for sox
+      await execa('which', ['sox'], { reject: true });
+      voiceAvailable = true;
+    } else {
+      // Linux - check for sox or arecord
+      try {
+        await execa('which', ['sox'], { reject: true });
+        voiceAvailable = true;
+      } catch {
+        await execa('which', ['arecord'], { reject: true });
+        voiceAvailable = true;
+      }
+    }
+  } catch {
+    voiceAvailable = false;
+  }
+  
+  return voiceAvailable;
+}
+
+/**
+ * Enhanced text input that supports voice
+ * User can type "voice" or "v" to switch to voice input
+ */
+export async function textWithVoice(options: {
+  message: string;
+  placeholder?: string;
+  initialValue?: string;
+  validate?: (value: string) => string | undefined;
+}): Promise<string | symbol> {
+  const hasVoice = await checkVoiceAvailability();
+  
+  const hint = hasVoice ? chalk.dim(' (type "v" for voice)') : '';
+  
+  const result = await p.text({
+    message: options.message + hint,
+    placeholder: options.placeholder,
+    initialValue: options.initialValue,
+    validate: (value) => {
+      // Don't validate if they're switching to voice
+      if (value.toLowerCase() === 'v' || value.toLowerCase() === 'voice') {
+        return undefined;
+      }
+      return options.validate?.(value);
+    },
+  });
+
+  if (p.isCancel(result)) return result;
+
+  // Check if user wants voice input
+  const val = (result as string).toLowerCase().trim();
+  if (val === 'v' || val === 'voice') {
+    if (!hasVoice) {
+      console.log(chalk.yellow('Voice input not available on this system.'));
+      return textWithVoice(options); // Try again with text
+    }
+    
+    const voiceResult = await getVoiceInput(options.message);
+    if (voiceResult === null) {
+      return textWithVoice(options); // Cancelled, try again
+    }
+    
+    // Validate voice result
+    if (options.validate) {
+      const error = options.validate(voiceResult);
+      if (error) {
+        console.log(chalk.red(error));
+        return textWithVoice(options);
+      }
+    }
+    
+    return voiceResult;
+  }
+
+  return result;
+}
+
+/**
+ * Get voice input from microphone
+ */
+export async function getVoiceInput(prompt: string): Promise<string | null> {
+  console.log(chalk.cyan(`\n🎤 ${prompt}`));
+  console.log(chalk.dim('   Speak after the beep. Recording stops after silence.\n'));
+
+  const ready = await p.confirm({
+    message: 'Ready to record?',
+    initialValue: true,
+  });
+
+  if (!ready || p.isCancel(ready)) {
+    return null;
+  }
+
+  // Play a beep sound if possible
+  await playBeep();
+
+  const spinner = p.spinner();
+  spinner.start('🔴 Recording...');
+
+  try {
+    let transcription = '';
+    
+    if (process.platform === 'win32') {
+      transcription = await recordWithWindowsSpeech();
+    } else if (process.platform === 'darwin') {
+      transcription = await recordWithMacOS();
+    } else {
+      transcription = await recordWithLinux();
+    }
+
+    spinner.stop('Recording complete');
+
+    if (transcription) {
+      console.log(chalk.green(`\n   ✓ Heard: "${transcription}"\n`));
+      
+      const confirm = await p.confirm({
+        message: 'Is this correct?',
+        initialValue: true,
+      });
+
+      if (confirm && !p.isCancel(confirm)) {
+        return transcription;
+      } else {
+        const action = await p.select({
+          message: 'What would you like to do?',
+          options: [
+            { value: 'retry', label: '🎤 Try again' },
+            { value: 'type', label: '⌨️  Type instead' },
+            { value: 'cancel', label: '✗ Cancel' },
+          ],
+        });
+
+        if (p.isCancel(action) || action === 'cancel') return null;
+        
+        if (action === 'retry') {
+          return await getVoiceInput(prompt);
+        } else {
+          const text = await p.text({ message: 'Type your response:' });
+          return p.isCancel(text) ? null : text as string;
+        }
+      }
+    } else {
+      console.log(chalk.yellow('\n   No speech detected. Try again or type your response.\n'));
+      
+      const text = await p.text({ message: 'Type instead:' });
+      return p.isCancel(text) ? null : text as string;
+    }
+  } catch (error) {
+    spinner.stop('Recording failed');
+    console.log(chalk.yellow('Voice input failed. Please type instead.'));
+    
+    const text = await p.text({ message: prompt });
+    return p.isCancel(text) ? null : text as string;
+  }
+}
+
+async function playBeep(): Promise<void> {
+  try {
+    if (process.platform === 'win32') {
+      await execa('powershell', ['-Command', '[console]::beep(800,200)'], { reject: false });
+    } else if (process.platform === 'darwin') {
+      await execa('afplay', ['/System/Library/Sounds/Tink.aiff'], { reject: false });
+    } else {
+      // Linux - try beep or paplay
+      try {
+        await execa('beep', ['-f', '800', '-l', '200'], { reject: false });
+      } catch {
+        await execa('paplay', ['/usr/share/sounds/freedesktop/stereo/message.oga'], { reject: false });
+      }
+    }
+  } catch {
+    // Silent fail - beep is optional
+  }
+}
+
+async function recordWithWindowsSpeech(): Promise<string> {
+  const psScript = `
+Add-Type -AssemblyName System.Speech
+$recognizer = New-Object System.Speech.Recognition.SpeechRecognitionEngine
+$recognizer.SetInputToDefaultAudioDevice()
+$grammar = New-Object System.Speech.Recognition.DictationGrammar
+$recognizer.LoadGrammar($grammar)
+try {
+    $result = $recognizer.Recognize([TimeSpan]::FromSeconds(10))
+    if ($result) { 
+        Write-Output $result.Text 
+    }
+} finally {
+    $recognizer.Dispose()
+}
+`;
+
+  try {
+    const result = await execa('powershell', ['-Command', psScript], {
+      timeout: 15000,
+    });
+    return result.stdout.trim();
+  } catch {
+    return '';
+  }
+}
+
+async function recordWithMacOS(): Promise<string> {
+  const tempFile = `/tmp/codebakers-voice-${Date.now()}.wav`;
+  
+  try {
+    // Record with sox - stops on silence
+    await execa('sox', [
+      '-d',           // default input
+      '-r', '16000',  // sample rate
+      '-c', '1',      // mono
+      '-b', '16',     // 16-bit
+      tempFile,
+      'silence', '1', '0.1', '3%',  // start on sound
+      '1', '2.0', '3%',             // stop after 2s silence
+      'trim', '0', '30',            // max 30 seconds
+    ], { timeout: 35000 });
+
+    // Try whisper for transcription
+    return await transcribeWithWhisper(tempFile);
+  } finally {
+    await fs.remove(tempFile).catch(() => {});
+  }
+}
+
+async function recordWithLinux(): Promise<string> {
+  const tempFile = `/tmp/codebakers-voice-${Date.now()}.wav`;
+  
+  try {
+    // Try sox first
+    try {
+      await execa('sox', [
+        '-d', tempFile,
+        'rate', '16000',
+        'channels', '1',
+        'silence', '1', '0.1', '3%',
+        '1', '2.0', '3%',
+        'trim', '0', '30',
+      ], { timeout: 35000 });
+    } catch {
+      // Fall back to arecord
+      await execa('arecord', [
+        '-f', 'S16_LE',
+        '-r', '16000',
+        '-c', '1',
+        '-d', '10',
+        tempFile,
+      ], { timeout: 15000 });
+    }
+
+    return await transcribeWithWhisper(tempFile);
+  } finally {
+    await fs.remove(tempFile).catch(() => {});
+  }
+}
+
+async function transcribeWithWhisper(audioFile: string): Promise<string> {
+  try {
+    // Try local whisper first
+    const outputBase = audioFile.replace('.wav', '');
+    
+    await execa('whisper', [
+      audioFile,
+      '--language', 'en',
+      '--output_format', 'txt',
+      '--output_dir', '/tmp',
+    ], { timeout: 60000 });
+    
+    const txtFile = outputBase + '.txt';
+    if (await fs.pathExists(txtFile)) {
+      const text = await fs.readFile(txtFile, 'utf-8');
+      await fs.remove(txtFile).catch(() => {});
+      return text.trim();
+    }
+  } catch {
+    // Whisper not available - try online API or return empty
+  }
+  
+  return '';
+}
+
+/**
+ * Voice-enabled select (read options aloud, accept voice selection)
+ */
+export async function selectWithVoice<T extends string>(options: {
+  message: string;
+  options: Array<{ value: T; label: string; hint?: string }>;
+}): Promise<T | symbol> {
+  // For now, just use regular select
+  // Voice selection is complex and error-prone
+  return p.select(options) as Promise<T | symbol>;
+}
+
+/**
+ * Voice-enabled confirm
+ */
+export async function confirmWithVoice(options: {
+  message: string;
+  initialValue?: boolean;
+}): Promise<boolean | symbol> {
+  const hasVoice = await checkVoiceAvailability();
+  const hint = hasVoice ? chalk.dim(' (say "yes" or "no")') : '';
+  
+  return p.confirm({
+    message: options.message + hint,
+    initialValue: options.initialValue,
+  });
+}