codebakers 2.0.3 → 2.0.10

package/src/commands/prd-maker.ts

@@ -0,0 +1,587 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import Anthropic from '@anthropic-ai/sdk';
+import { Config } from '../utils/config.js';
+import { textWithVoice, getVoiceInput, checkVoiceAvailability } from '../utils/voice.js';
+
+interface PRDInput {
+  projectName: string;
+  problemStatement: string;
+  targetUsers: string;
+  coreFeatures: string[];
+  userStories: string[];
+  technicalRequirements: string;
+  designPreferences: string;
+  timeline: string;
+  budget: string;
+  competitors: string;
+  successMetrics: string;
+  additionalNotes: string;
+}
+
+export async function prdMakerCommand(): Promise<void> {
+  const config = new Config();
+
+  if (!config.isConfigured()) {
+    p.log.error('Please run `codebakers setup` first.');
+    return;
+  }
+
+  const anthropicCreds = config.getCredentials('anthropic');
+  if (!anthropicCreds?.apiKey) {
+    p.log.error('Anthropic API key not configured.');
+    return;
+  }
+
+  console.log(chalk.cyan(`
+╭─────────────────────────────────────────────────────────────────╮
+│                                                                 │
+│   📝 CODEBAKERS PRD MAKER                                       │
+│                                                                 │
+│   I'll interview you about your product idea and generate       │
+│   a professional PRD document you can use to:                   │
+│                                                                 │
+│   • Share with developers or stakeholders                       │
+│   • Feed directly into \`codebakers prd\` to build it            │
+│   • Get Dream Team feedback with \`codebakers advisors\`          │
+│                                                                 │
+│   🎤 TIP: You can use voice input! Say "voice" at any prompt.  │
+│                                                                 │
+╰─────────────────────────────────────────────────────────────────╯
+`));
+
+  const inputMethod = await p.select({
+    message: 'How do you want to provide input?',
+    options: [
+      { value: 'text', label: '⌨️  Type responses' },
+      { value: 'voice', label: '🎤 Use microphone (voice input)' },
+      { value: 'mixed', label: '🔀 Mixed (type or speak per question)' },
+    ],
+  });
+
+  if (p.isCancel(inputMethod)) return;
+
+  const useVoice = inputMethod === 'voice' || inputMethod === 'mixed';
+  
+  if (useVoice) {
+    const voiceAvailable = await checkVoiceAvailability();
+    if (!voiceAvailable) {
+      p.log.warn('Voice input not available on this system. Falling back to text.');
+    }
+  }
+
+  // Conduct the interview
+  const input = await conductPRDInterview(inputMethod as string);
+  if (!input) return;
+
+  // Generate PRD with Claude
+  const anthropic = new Anthropic({ apiKey: anthropicCreds.apiKey });
+  
+  const spinner = p.spinner();
+  spinner.start('Generating professional PRD...');
+
+  const prd = await generatePRD(anthropic, input);
+
+  spinner.stop('PRD generated!');
+
+  // Save PRD
+  const filename = `${input.projectName.toLowerCase().replace(/[^a-z0-9]/g, '-')}-prd.md`;
+  const filepath = path.join(process.cwd(), filename);
+  await fs.writeFile(filepath, prd);
+
+  // Also save as JSON for programmatic use
+  const jsonPath = filepath.replace('.md', '.json');
+  await fs.writeJson(jsonPath, input, { spaces: 2 });
+
+  console.log(chalk.green(`
+╔════════════════════════════════════════════════════════════════╗
+║  ✓ PRD Generated Successfully!                                 ║
+╠════════════════════════════════════════════════════════════════╣
+║                                                                ║
+║  📄 Markdown: ${filename.padEnd(43)}║
+║  📊 Data:     ${(filename.replace('.md', '.json')).padEnd(43)}║
+║                                                                ║
+╠════════════════════════════════════════════════════════════════╣
+║  Next steps:                                                   ║
+║                                                                ║
+║  • View PRD:        cat ${filename.padEnd(34)}║
+║  • Build it:        codebakers prd ${filename.padEnd(23)}║
+║  • Get feedback:    codebakers advisors                        ║
+║                                                                ║
+╚════════════════════════════════════════════════════════════════╝
+`));
+
+  // Preview option
+  const preview = await p.confirm({
+    message: 'Preview the PRD now?',
+    initialValue: true,
+  });
+
+  if (preview && !p.isCancel(preview)) {
+    console.log(chalk.cyan('\n' + '═'.repeat(60) + '\n'));
+    console.log(prd);
+    console.log(chalk.cyan('\n' + '═'.repeat(60) + '\n'));
+  }
+
+  // Offer next steps
+  const nextStep = await p.select({
+    message: 'What would you like to do next?',
+    options: [
+      { value: 'build', label: '🚀 Build this project now' },
+      { value: 'advisors', label: '🌟 Get Dream Team feedback first' },
+      { value: 'done', label: '✓ Done for now' },
+    ],
+  });
+
+  if (p.isCancel(nextStep) || nextStep === 'done') {
+    p.outro('PRD saved!');
+    return;
+  }
+
+  if (nextStep === 'build') {
+    const { prdCommand } = await import('./prd.js');
+    await prdCommand(filepath);
+  } else if (nextStep === 'advisors') {
+    const { advisorsCommand } = await import('./advisors.js');
+    await advisorsCommand();
+  }
+}
+
+async function conductPRDInterview(inputMethod: string): Promise<PRDInput | null> {
+  const getInput = async (message: string, placeholder?: string): Promise<string | null> => {
+    if (inputMethod === 'voice') {
+      return await getVoiceInput(message);
+    } else if (inputMethod === 'mixed') {
+      const method = await p.select({
+        message: `${message}`,
+        options: [
+          { value: 'type', label: '⌨️  Type response' },
+          { value: 'voice', label: '🎤 Speak response' },
+        ],
+      });
+      if (p.isCancel(method)) return null;
+      
+      if (method === 'voice') {
+        return await getVoiceInput(message);
+      }
+    }
+    
+    const response = await p.text({
+      message,
+      placeholder,
+    });
+    
+    if (p.isCancel(response)) return null;
+    return response as string;
+  };
+
+  console.log(chalk.bold('\n📋 Let\'s build your PRD!\n'));
+
+  // Project basics
+  const projectName = await getInput(
+    'What\'s your project/product name?',
+    'My Awesome App'
+  );
+  if (!projectName) return null;
+
+  const problemStatement = await getInput(
+    'What problem does this solve? Who has this problem and why is it painful?',
+    'Small business owners struggle with...'
+  );
+  if (!problemStatement) return null;
+
+  const targetUsers = await getInput(
+    'Who are your target users? Be specific about demographics, roles, etc.',
+    'Marketing managers at companies with 10-50 employees...'
+  );
+  if (!targetUsers) return null;
+
+  // Features
+  console.log(chalk.bold('\n🎯 Core Features\n'));
+  console.log(chalk.dim('List the main features. Type each one and press Enter. Type "done" when finished.\n'));
+
+  const coreFeatures: string[] = [];
+  while (true) {
+    const feature = await getInput(
+      `Feature ${coreFeatures.length + 1} (or "done"):`,
+      'User authentication with social login'
+    );
+    if (!feature) return null;
+    if (feature.toLowerCase() === 'done') break;
+    coreFeatures.push(feature);
+  }
+
+  // User stories
+  console.log(chalk.bold('\n👤 User Stories\n'));
+  console.log(chalk.dim('Describe key user journeys. Type "done" when finished.\n'));
+
+  const userStories: string[] = [];
+  while (true) {
+    const story = await getInput(
+      `User story ${userStories.length + 1} (or "done"):`,
+      'As a user, I want to... so that I can...'
+    );
+    if (!story) return null;
+    if (story.toLowerCase() === 'done') break;
+    userStories.push(story);
+  }
+
+  // Technical
+  const technicalRequirements = await getInput(
+    'Any technical requirements or constraints? (platforms, integrations, etc.)',
+    'Must work on mobile, integrate with Stripe, support 10k users...'
+  );
+  if (!technicalRequirements) return null;
+
+  // Design
+  const designPreferences = await getInput(
+    'Design preferences? (style, colors, inspiration sites)',
+    'Clean and minimal like Linear, blue accent color...'
+  );
+  if (!designPreferences) return null;
+
+  // Business
+  const timeline = await p.select({
+    message: 'What\'s your timeline?',
+    options: [
+      { value: '1-week', label: '1 week (MVP)' },
+      { value: '2-weeks', label: '2 weeks' },
+      { value: '1-month', label: '1 month' },
+      { value: '3-months', label: '3 months' },
+      { value: 'flexible', label: 'Flexible' },
+    ],
+  });
+  if (p.isCancel(timeline)) return null;
+
+  const budget = await p.select({
+    message: 'What\'s your budget?',
+    options: [
+      { value: 'bootstrap', label: 'Bootstrap (free tiers only)' },
+      { value: 'small', label: 'Small ($100-500/month)' },
+      { value: 'medium', label: 'Medium ($500-2000/month)' },
+      { value: 'funded', label: 'Funded ($2000+/month)' },
+    ],
+  });
+  if (p.isCancel(budget)) return null;
+
+  const competitors = await getInput(
+    'Who are your competitors? How are you different?',
+    'Competitor X does Y, but we focus on Z...'
+  );
+  if (!competitors) return null;
+
+  const successMetrics = await getInput(
+    'How will you measure success? What are your KPIs?',
+    '1000 users in first month, 5% conversion rate...'
+  );
+  if (!successMetrics) return null;
+
+  const additionalNotes = await getInput(
+    'Anything else we should know?',
+    'Optional: special requirements, existing assets, etc.'
+  );
+  if (additionalNotes === null) return null;
+
+  return {
+    projectName,
+    problemStatement,
+    targetUsers,
+    coreFeatures,
+    userStories,
+    technicalRequirements,
+    designPreferences,
+    timeline: timeline as string,
+    budget: budget as string,
+    competitors,
+    successMetrics,
+    additionalNotes: additionalNotes || '',
+  };
+}
+
+async function checkVoiceAvailability(): Promise<boolean> {
+  try {
+    // Check for sox (Sound eXchange) - cross-platform audio tool
+    await execa('sox', ['--version'], { reject: true });
+    return true;
+  } catch {
+    try {
+      // Windows: check for powershell speech recognition
+      if (process.platform === 'win32') {
+        return true; // We'll use PowerShell
+      }
+      // macOS: check for say command (for feedback) 
+      if (process.platform === 'darwin') {
+        await execa('which', ['say'], { reject: true });
+        return true;
+      }
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+async function getVoiceInput(prompt: string): Promise<string | null> {
+  console.log(chalk.cyan(`\n🎤 ${prompt}`));
+  console.log(chalk.dim('   Press Enter to start recording, then speak. Press Enter again to stop.\n'));
+
+  const ready = await p.confirm({
+    message: 'Ready to record?',
+    initialValue: true,
+  });
+
+  if (!ready || p.isCancel(ready)) {
+    // Fall back to text
+    const text = await p.text({ message: 'Type instead:' });
+    return p.isCancel(text) ? null : text as string;
+  }
+
+  const spinner = p.spinner();
+  spinner.start('🔴 Recording... (press Ctrl+C to stop)');
+
+  try {
+    let transcription = '';
+    
+    if (process.platform === 'win32') {
+      // Windows: Use PowerShell with System.Speech
+      transcription = await recordWithWindowsSpeech();
+    } else if (process.platform === 'darwin') {
+      // macOS: Use sox + whisper or built-in dictation
+      transcription = await recordWithMacOS();
+    } else {
+      // Linux: Use sox + whisper
+      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 {
+        // Let them try again or type
+        const retry = await p.select({
+          message: 'What would you like to do?',
+          options: [
+            { value: 'retry', label: '🎤 Try again' },
+            { value: 'type', label: '⌨️  Type instead' },
+          ],
+        });
+
+        if (p.isCancel(retry)) return null;
+        
+        if (retry === 'retry') {
+          return await getVoiceInput(prompt);
+        } else {
+          const text = await p.text({ message: 'Type your response:' });
+          return p.isCancel(text) ? null : text as string;
+        }
+      }
+    }
+  } catch (error) {
+    spinner.stop('Recording failed');
+    console.log(chalk.yellow('Voice input failed. Falling back to text.'));
+  }
+
+  // Fallback to text
+  const text = await p.text({ message: prompt });
+  return p.isCancel(text) ? null : text as string;
+}
+
+async function recordWithWindowsSpeech(): Promise<string> {
+  // PowerShell script for Windows Speech Recognition
+  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)
+$result = $recognizer.Recognize()
+if ($result) { Write-Output $result.Text }
+`;
+
+  try {
+    const result = await execa('powershell', ['-Command', psScript], {
+      timeout: 30000, // 30 second timeout
+    });
+    return result.stdout.trim();
+  } catch {
+    return '';
+  }
+}
+
+async function recordWithMacOS(): Promise<string> {
+  // Use sox to record, then use macOS dictation or whisper
+  const tempFile = `/tmp/codebakers-voice-${Date.now()}.wav`;
+  
+  try {
+    // Record 10 seconds of audio
+    console.log(chalk.dim('   Recording for up to 10 seconds...'));
+    
+    await execa('sox', [
+      '-d', // default input device
+      '-r', '16000', // sample rate
+      '-c', '1', // mono
+      '-b', '16', // 16-bit
+      tempFile,
+      'trim', '0', '10', // max 10 seconds
+      'silence', '1', '0.5', '1%', // stop on silence
+    ], { timeout: 15000 });
+
+    // Try to use whisper if available, otherwise return empty
+    try {
+      const result = await execa('whisper', [tempFile, '--language', 'en', '--output_format', 'txt'], {
+        timeout: 30000,
+      });
+      const txtFile = tempFile.replace('.wav', '.txt');
+      if (await fs.pathExists(txtFile)) {
+        const text = await fs.readFile(txtFile, 'utf-8');
+        await fs.remove(txtFile);
+        return text.trim();
+      }
+    } catch {
+      // Whisper not available
+    }
+
+    return '';
+  } finally {
+    // Cleanup
+    await fs.remove(tempFile).catch(() => {});
+  }
+}
+
+async function recordWithLinux(): Promise<string> {
+  // Similar to macOS but with arecord as fallback
+  const tempFile = `/tmp/codebakers-voice-${Date.now()}.wav`;
+  
+  try {
+    // Try sox first
+    try {
+      await execa('sox', [
+        '-d', tempFile,
+        'rate', '16000',
+        'channels', '1',
+        'trim', '0', '10',
+        'silence', '1', '0.5', '1%',
+      ], { timeout: 15000 });
+    } catch {
+      // Fall back to arecord
+      await execa('arecord', [
+        '-f', 'S16_LE',
+        '-r', '16000',
+        '-c', '1',
+        '-d', '10',
+        tempFile,
+      ], { timeout: 15000 });
+    }
+
+    // Try whisper
+    try {
+      const result = await execa('whisper', [tempFile, '--language', 'en', '--output_format', 'txt'], {
+        timeout: 30000,
+      });
+      const txtFile = tempFile.replace('.wav', '.txt');
+      if (await fs.pathExists(txtFile)) {
+        const text = await fs.readFile(txtFile, 'utf-8');
+        await fs.remove(txtFile);
+        return text.trim();
+      }
+    } catch {
+      // Whisper not available
+    }
+
+    return '';
+  } finally {
+    await fs.remove(tempFile).catch(() => {});
+  }
+}
+
+async function generatePRD(anthropic: Anthropic, input: PRDInput): Promise<string> {
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 8192,
+    messages: [{
+      role: 'user',
+      content: `Generate a professional, comprehensive Product Requirements Document (PRD) based on this input:
+
+PROJECT NAME: ${input.projectName}
+
+PROBLEM STATEMENT:
+${input.problemStatement}
+
+TARGET USERS:
+${input.targetUsers}
+
+CORE FEATURES:
+${input.coreFeatures.map((f, i) => `${i + 1}. ${f}`).join('\n')}
+
+USER STORIES:
+${input.userStories.map((s, i) => `${i + 1}. ${s}`).join('\n')}
+
+TECHNICAL REQUIREMENTS:
+${input.technicalRequirements}
+
+DESIGN PREFERENCES:
+${input.designPreferences}
+
+TIMELINE: ${input.timeline}
+BUDGET: ${input.budget}
+
+COMPETITORS:
+${input.competitors}
+
+SUCCESS METRICS:
+${input.successMetrics}
+
+ADDITIONAL NOTES:
+${input.additionalNotes}
+
+---
+
+Generate a detailed PRD in Markdown format with the following sections:
+
+1. **Executive Summary** - Brief overview of the product
+2. **Problem Statement** - Detailed problem analysis
+3. **Target Audience** - User personas with demographics
+4. **Goals & Objectives** - SMART goals
+5. **Features & Requirements**
+   - Core Features (P0)
+   - Secondary Features (P1)
+   - Nice-to-Have (P2)
+6. **User Stories & Flows** - Detailed user journeys
+7. **Technical Specifications**
+   - Recommended Tech Stack
+   - Architecture Overview
+   - Database Schema (key tables)
+   - API Endpoints (key endpoints)
+   - Third-party Integrations
+8. **Design Requirements**
+   - Design Principles
+   - Key Screens
+   - Branding Guidelines
+9. **Timeline & Milestones**
+   - Phase breakdown
+   - Deliverables per phase
+10. **Success Metrics & KPIs**
+11. **Risks & Mitigations**
+12. **Out of Scope** - What this does NOT include
+13. **Open Questions** - Things that need clarification
+14. **Appendix**
+    - Competitive Analysis
+    - Technical Glossary
+
+Make it professional, detailed, and actionable. This should be ready to hand off to developers.`
+    }],
+  });
+
+  return response.content[0].type === 'text' ? response.content[0].text : '';
+}