codebakers 2.5.3 → 3.0.0

package/src/utils/voice.ts

@@ -1,323 +0,0 @@
-import * as p from '@clack/prompts';
-import chalk from 'chalk';
-import 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,
-  });
-}

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": false,
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "templates"]
-}