codebakers 2.0.4 → 2.0.10

package/src/index.ts

@@ -23,8 +23,11 @@ import { designCommand } from './commands/design.js';
 import { prdCommand } from './commands/prd.js';
 import { advisorsCommand } from './commands/advisors.js';
 import { migrateCommand } from './commands/migrate.js';
+import { prdMakerCommand } from './commands/prd-maker.js';
+import { buildCommand } from './commands/build.js';
+import { parseNaturalLanguage, clarifyCommand, clarifyDeployTarget } from './utils/nlp.js';
 
-const VERSION = '1.0.0';
+const VERSION = '2.0.9';
 
 // ASCII art logo
 const logo = `
@@ -60,7 +63,7 @@ async function showMainMenu(): Promise<void> {
 
   // Main menu
   const action = await p.select({
-    message: 'What do you want to do?',
+    message: 'What do you want to do? (or type naturally)',
     options: inProject ? [
       { value: 'code', label: '💬 Code with AI', hint: 'build features, fix bugs' },
       { value: 'check', label: '🔍 Check code quality', hint: 'run pattern enforcement' },
@@ -77,13 +80,17 @@ async function showMainMenu(): Promise<void> {
       { value: 'design', label: '🎨 Design system', hint: 'set profile, colors' },
       { value: 'separator2', label: '─────────────────────────' },
       { value: 'new', label: '🆕 Create new project' },
-      { value: 'prd', label: '📄 Build from PRD', hint: 'upload a PRD document' },
+      { value: 'build', label: '🏗️  Parallel Build', hint: '3 agents from PRD (swarm)' },
+      { value: 'prd', label: '📄 Build from PRD', hint: 'sequential build' },
+      { value: 'prd-maker', label: '✏️  Create PRD', hint: 'interview → generate PRD' },
       { value: 'advisors', label: '🌟 Dream Team Advisors', hint: 'consult with experts' },
       { value: 'settings', label: '⚙️  Settings' },
       { value: 'help', label: '❓ Help' },
     ] : [
       { value: 'new', label: '🆕 Create new project' },
-      { value: 'prd', label: '📄 Build from PRD', hint: 'upload a PRD document' },
+      { value: 'build', label: '🏗️  Parallel Build', hint: '3 agents from PRD (swarm)' },
+      { value: 'prd', label: '📄 Build from PRD', hint: 'sequential build' },
+      { value: 'prd-maker', label: '✏️  Create PRD', hint: 'interview → generate PRD' },
       { value: 'advisors', label: '🌟 Dream Team Advisors', hint: 'consult with experts' },
       { value: 'open', label: '📂 Open existing project' },
       { value: 'status', label: '📊 View all projects' },
@@ -142,9 +149,15 @@ async function showMainMenu(): Promise<void> {
     case 'new':
       await initCommand();
       break;
+    case 'build':
+      await buildCommand();
+      break;
     case 'prd':
       await prdCommand();
       break;
+    case 'prd-maker':
+      await prdMakerCommand();
+      break;
     case 'advisors':
       await advisorsCommand();
       break;
@@ -301,6 +314,93 @@ program
   .option('--status', 'Check migration status')
   .action(migrateCommand);
 
+program
+  .command('prd-maker')
+  .alias('create-prd')
+  .description('Create a PRD through guided interview (supports voice input)')
+  .action(prdMakerCommand);
+
+program
+  .command('build [prd-file]')
+  .alias('swarm')
+  .description('Parallel build with 3 AI agents (self-healing)')
+  .option('--sequential', 'Disable parallel execution')
+  .action(buildCommand);
+
+// Natural language processing for free-form input
+async function handleNaturalLanguage(input: string): Promise<void> {
+  const config = new Config();
+  
+  console.log(chalk.dim('\n  Parsing your request...\n'));
+  
+  const parsed = await parseNaturalLanguage(input, config);
+  
+  if (!parsed) {
+    // Fall back to code command
+    await codeCommand(input);
+    return;
+  }
+
+  // Clarify if needed
+  const clarified = await clarifyCommand(parsed);
+  
+  if (clarified.command === 'cancel') {
+    return;
+  }
+
+  // Execute the command
+  switch (clarified.command) {
+    case 'init':
+      await initCommand();
+      break;
+    case 'build':
+      await buildCommand(clarified.args[0]);
+      break;
+    case 'code':
+      await codeCommand(clarified.args.join(' '));
+      break;
+    case 'check':
+      await checkCommand();
+      break;
+    case 'deploy':
+      const target = await clarifyDeployTarget();
+      if (target) {
+        await deployCommand({ preview: target === 'preview' });
+      }
+      break;
+    case 'fix':
+      await fixCommand();
+      break;
+    case 'migrate':
+      await migrateCommand();
+      break;
+    case 'design':
+      await designCommand();
+      break;
+    case 'advisors':
+      await advisorsCommand();
+      break;
+    case 'prd-maker':
+      await prdMakerCommand();
+      break;
+    case 'security':
+      await securityCommand();
+      break;
+    case 'status':
+      await statusCommand();
+      break;
+    case 'setup':
+      await setupCommand();
+      break;
+    case 'help':
+      showHelp();
+      break;
+    default:
+      // Unknown command - pass to code agent
+      await codeCommand(input);
+  }
+}
+
 // Parse args or show menu
 const args = process.argv.slice(2);
 
@@ -310,6 +410,24 @@ if (args.length === 0) {
   
   // Show interactive menu
   showMainMenu().catch(console.error);
+} else if (args.length > 0 && args[0] && !args[0].startsWith('-')) {
+  // Check if it's a known command
+  const knownCommands = [
+    'setup', 'init', 'code', 'check', 'deploy', 'fix', 'generate',
+    'connect', 'status', 'gateway', 'security', 'learn', 'design',
+    'prd', 'advisors', 'migrate', 'prd-maker', 'build', 'swarm', 'help'
+  ];
+  
+  const firstArg = args[0] as string;
+  
+  if (knownCommands.includes(firstArg)) {
+    program.parse();
+  } else {
+    // Natural language input
+    const input = args.join(' ');
+    checkForUpdates().catch(() => {});
+    handleNaturalLanguage(input).catch(console.error);
+  }
 } else {
   program.parse();
 }

package/src/utils/files.ts

@@ -0,0 +1,418 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { execa } from 'execa';
+
+/**
+ * Read content from clipboard
+ */
+export async function readClipboard(): Promise<string | null> {
+  try {
+    if (process.platform === 'win32') {
+      // Windows: PowerShell Get-Clipboard
+      const result = await execa('powershell', ['-Command', 'Get-Clipboard'], { timeout: 5000 });
+      return result.stdout;
+    } else if (process.platform === 'darwin') {
+      // macOS: pbpaste
+      const result = await execa('pbpaste', [], { timeout: 5000 });
+      return result.stdout;
+    } else {
+      // Linux: xclip or xsel
+      try {
+        const result = await execa('xclip', ['-selection', 'clipboard', '-o'], { timeout: 5000 });
+        return result.stdout;
+      } catch {
+        const result = await execa('xsel', ['--clipboard', '--output'], { timeout: 5000 });
+        return result.stdout;
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read a file from path (supports drag & drop paths)
+ */
+export async function readFile(filePath: string): Promise<{ content: string; type: string; name: string } | null> {
+  try {
+    // Clean up the path (remove quotes, handle drag & drop formatting)
+    let cleanPath = filePath.trim();
+    
+    // Remove surrounding quotes (common when drag & dropping)
+    if ((cleanPath.startsWith('"') && cleanPath.endsWith('"')) ||
+        (cleanPath.startsWith("'") && cleanPath.endsWith("'"))) {
+      cleanPath = cleanPath.slice(1, -1);
+    }
+    
+    // Handle Windows paths with spaces
+    cleanPath = cleanPath.replace(/\\ /g, ' ');
+    
+    // Check if file exists
+    if (!await fs.pathExists(cleanPath)) {
+      return null;
+    }
+
+    const stats = await fs.stat(cleanPath);
+    
+    // Don't read files larger than 10MB
+    if (stats.size > 10 * 1024 * 1024) {
+      console.log(chalk.yellow('File too large (max 10MB)'));
+      return null;
+    }
+
+    const ext = path.extname(cleanPath).toLowerCase();
+    const name = path.basename(cleanPath);
+    
+    // Determine file type
+    const textExtensions = [
+      '.txt', '.md', '.json', '.js', '.ts', '.tsx', '.jsx',
+      '.css', '.scss', '.html', '.xml', '.yaml', '.yml',
+      '.py', '.rb', '.go', '.rs', '.java', '.c', '.cpp', '.h',
+      '.sql', '.sh', '.bash', '.zsh', '.fish', '.ps1',
+      '.env', '.gitignore', '.dockerfile', '.toml', '.ini', '.cfg',
+      '.csv', '.log', '.mdx', '.astro', '.vue', '.svelte',
+    ];
+
+    const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp'];
+    const pdfExtensions = ['.pdf'];
+    
+    if (textExtensions.includes(ext) || ext === '') {
+      // Read as text
+      const content = await fs.readFile(cleanPath, 'utf-8');
+      return { content, type: 'text', name };
+    } else if (imageExtensions.includes(ext)) {
+      // Read as base64 for images
+      const buffer = await fs.readFile(cleanPath);
+      const base64 = buffer.toString('base64');
+      const mimeType = getMimeType(ext);
+      return { 
+        content: `data:${mimeType};base64,${base64}`, 
+        type: 'image', 
+        name 
+      };
+    } else if (pdfExtensions.includes(ext)) {
+      // For PDFs, try to extract text
+      const text = await extractPdfText(cleanPath);
+      if (text) {
+        return { content: text, type: 'pdf', name };
+      }
+      // Fall back to noting it's a PDF
+      return { 
+        content: `[PDF file: ${name} - text extraction not available]`, 
+        type: 'pdf', 
+        name 
+      };
+    } else {
+      // Try to read as text anyway
+      try {
+        const content = await fs.readFile(cleanPath, 'utf-8');
+        // Check if it's actually text (not binary)
+        if (content.includes('\0')) {
+          return { 
+            content: `[Binary file: ${name}]`, 
+            type: 'binary', 
+            name 
+          };
+        }
+        return { content, type: 'text', name };
+      } catch {
+        return { 
+          content: `[Unsupported file type: ${name}]`, 
+          type: 'unknown', 
+          name 
+        };
+      }
+    }
+  } catch (error) {
+    console.log(chalk.red(`Error reading file: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    return null;
+  }
+}
+
+/**
+ * Extract text from PDF using pdftotext or pdf-parse
+ */
+async function extractPdfText(filePath: string): Promise<string | null> {
+  try {
+    // Try pdftotext (poppler-utils)
+    const result = await execa('pdftotext', [filePath, '-'], { timeout: 30000 });
+    return result.stdout;
+  } catch {
+    // pdftotext not available
+    return null;
+  }
+}
+
+function getMimeType(ext: string): string {
+  const mimeTypes: Record<string, string> = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.bmp': 'image/bmp',
+  };
+  return mimeTypes[ext] || 'application/octet-stream';
+}
+
+/**
+ * Watch for file drops/pastes and integrate with text input
+ * Returns enhanced input with file contents
+ */
+export async function textWithFileSupport(options: {
+  message: string;
+  placeholder?: string;
+}): Promise<{ text: string; files: Array<{ name: string; content: string; type: string }> } | symbol> {
+  
+  const hint = chalk.dim(' (paste file path, or "clip" for clipboard)');
+  
+  const input = await p.text({
+    message: options.message + hint,
+    placeholder: options.placeholder,
+  });
+
+  if (p.isCancel(input)) return input;
+  
+  const text = (input as string).trim();
+  const files: Array<{ name: string; content: string; type: string }> = [];
+  
+  // Check for clipboard command
+  if (text.toLowerCase() === 'clip' || text.toLowerCase() === 'clipboard' || text.toLowerCase() === 'paste') {
+    const clipContent = await readClipboard();
+    if (clipContent) {
+      console.log(chalk.green(`\n📋 Read ${clipContent.length} characters from clipboard\n`));
+      
+      // Check if clipboard contains a file path
+      if (await fs.pathExists(clipContent.trim())) {
+        const file = await readFile(clipContent.trim());
+        if (file) {
+          files.push(file);
+          return { text: `[File: ${file.name}]`, files };
+        }
+      }
+      
+      // Otherwise treat as text
+      files.push({ name: 'clipboard', content: clipContent, type: 'text' });
+      
+      const preview = clipContent.length > 100 
+        ? clipContent.slice(0, 100) + '...' 
+        : clipContent;
+      console.log(chalk.dim(`Preview: ${preview}\n`));
+      
+      // Ask what to do with clipboard content
+      const action = await p.select({
+        message: 'What would you like me to do with this?',
+        options: [
+          { value: 'analyze', label: '🔍 Analyze this code/text' },
+          { value: 'fix', label: '🔧 Fix any issues' },
+          { value: 'explain', label: '📖 Explain this' },
+          { value: 'improve', label: '✨ Improve/refactor' },
+          { value: 'convert', label: '🔄 Convert to different format' },
+          { value: 'custom', label: '✏️  Custom instruction' },
+        ],
+      });
+      
+      if (p.isCancel(action)) return action;
+      
+      if (action === 'custom') {
+        const customPrompt = await p.text({
+          message: 'What should I do with this?',
+          placeholder: 'Add error handling to this function',
+        });
+        if (p.isCancel(customPrompt)) return customPrompt;
+        return { text: customPrompt as string, files };
+      }
+      
+      const actionText: Record<string, string> = {
+        analyze: 'Analyze this code/text and explain what it does',
+        fix: 'Fix any bugs, issues, or problems in this code',
+        explain: 'Explain this code/text in detail',
+        improve: 'Improve and refactor this code for better quality',
+        convert: 'Convert this to a better format or structure',
+      };
+      
+      return { text: actionText[action as string], files };
+    } else {
+      console.log(chalk.yellow('Clipboard is empty'));
+      // Re-prompt
+      return textWithFileSupport(options);
+    }
+  }
+  
+  // Check if input is a file path
+  if (await fs.pathExists(text)) {
+    const file = await readFile(text);
+    if (file) {
+      files.push(file);
+      console.log(chalk.green(`\n📄 Read file: ${file.name} (${file.type})\n`));
+      
+      // Ask what to do
+      const action = await p.select({
+        message: `What should I do with ${file.name}?`,
+        options: [
+          { value: 'analyze', label: '🔍 Analyze this file' },
+          { value: 'fix', label: '🔧 Fix any issues' },
+          { value: 'explain', label: '📖 Explain this' },
+          { value: 'improve', label: '✨ Improve/refactor' },
+          { value: 'custom', label: '✏️  Custom instruction' },
+        ],
+      });
+      
+      if (p.isCancel(action)) return action;
+      
+      if (action === 'custom') {
+        const customPrompt = await p.text({
+          message: 'What should I do with this file?',
+          placeholder: 'Add TypeScript types to this file',
+        });
+        if (p.isCancel(customPrompt)) return customPrompt;
+        return { text: customPrompt as string, files };
+      }
+      
+      const actionText: Record<string, string> = {
+        analyze: `Analyze this file (${file.name}) and explain what it does`,
+        fix: `Fix any bugs or issues in this file (${file.name})`,
+        explain: `Explain this file (${file.name}) in detail`,
+        improve: `Improve and refactor this file (${file.name})`,
+      };
+      
+      return { text: actionText[action as string], files };
+    }
+  }
+  
+  // Check if input contains multiple file paths (drag & drop multiple)
+  const potentialPaths = text.split('\n').map(p => p.trim()).filter(Boolean);
+  if (potentialPaths.length > 1) {
+    for (const potentialPath of potentialPaths) {
+      if (await fs.pathExists(potentialPath)) {
+        const file = await readFile(potentialPath);
+        if (file) {
+          files.push(file);
+        }
+      }
+    }
+    
+    if (files.length > 0) {
+      console.log(chalk.green(`\n📁 Read ${files.length} files: ${files.map(f => f.name).join(', ')}\n`));
+      
+      const instruction = await p.text({
+        message: 'What should I do with these files?',
+        placeholder: 'Combine these into a single component',
+      });
+      
+      if (p.isCancel(instruction)) return instruction;
+      return { text: instruction as string, files };
+    }
+  }
+  
+  // Regular text input
+  return { text, files };
+}
+
+/**
+ * Format files for Claude context
+ */
+export function formatFilesForContext(files: Array<{ name: string; content: string; type: string }>): string {
+  if (files.length === 0) return '';
+  
+  let context = '\n\n--- ATTACHED FILES ---\n\n';
+  
+  for (const file of files) {
+    if (file.type === 'image') {
+      context += `[Image: ${file.name}]\n`;
+      context += `${file.content}\n\n`; // base64 data URL
+    } else {
+      context += `--- ${file.name} ---\n`;
+      context += '```\n';
+      context += file.content;
+      context += '\n```\n\n';
+    }
+  }
+  
+  context += '--- END FILES ---\n\n';
+  
+  return context;
+}
+
+/**
+ * Quick paste detection - check if text looks like it was pasted
+ */
+export function looksLikePaste(text: string): boolean {
+  // Multi-line content is likely pasted
+  if (text.includes('\n') && text.split('\n').length > 3) return true;
+  
+  // Code-like content
+  if (text.includes('function ') || text.includes('const ') || 
+      text.includes('import ') || text.includes('export ') ||
+      text.includes('class ') || text.includes('def ') ||
+      text.includes('public ') || text.includes('private ')) return true;
+  
+  // JSON/object-like
+  if ((text.startsWith('{') && text.endsWith('}')) ||
+      (text.startsWith('[') && text.endsWith(']'))) return true;
+      
+  // Very long single line
+  if (text.length > 200 && !text.includes('\n')) return true;
+  
+  return false;
+}
+
+/**
+ * Handle pasted content intelligently
+ */
+export async function handlePastedContent(text: string): Promise<{ prompt: string; context: string } | null> {
+  if (!looksLikePaste(text)) {
+    return null; // Not pasted content, handle normally
+  }
+  
+  console.log(chalk.cyan('\n📋 Detected pasted content!\n'));
+  
+  const preview = text.length > 200 ? text.slice(0, 200) + '...' : text;
+  console.log(chalk.dim(preview));
+  console.log('');
+  
+  const action = await p.select({
+    message: 'What should I do with this?',
+    options: [
+      { value: 'analyze', label: '🔍 Analyze this code' },
+      { value: 'fix', label: '🔧 Fix any issues' },
+      { value: 'explain', label: '📖 Explain this' },
+      { value: 'improve', label: '✨ Improve/refactor' },
+      { value: 'custom', label: '✏️  Add my own instruction' },
+      { value: 'literal', label: '📝 Use as literal prompt (not code)' },
+    ],
+  });
+  
+  if (p.isCancel(action)) return null;
+  
+  if (action === 'literal') {
+    return { prompt: text, context: '' };
+  }
+  
+  if (action === 'custom') {
+    const instruction = await p.text({
+      message: 'What should I do?',
+      placeholder: 'Add error handling and types',
+    });
+    if (p.isCancel(instruction)) return null;
+    return { 
+      prompt: instruction as string, 
+      context: `\n\n--- PASTED CODE ---\n\`\`\`\n${text}\n\`\`\`\n--- END ---\n\n` 
+    };
+  }
+  
+  const actionPrompts: Record<string, string> = {
+    analyze: 'Analyze this code and explain what it does, any issues, and potential improvements',
+    fix: 'Fix any bugs, issues, or problems in this code',
+    explain: 'Explain this code in detail, step by step',
+    improve: 'Improve and refactor this code for better quality, readability, and performance',
+  };
+  
+  return { 
+    prompt: actionPrompts[action as string], 
+    context: `\n\n--- PASTED CODE ---\n\`\`\`\n${text}\n\`\`\`\n--- END ---\n\n` 
+  };
+}