codebakers 2.0.3 → 2.0.10

package/src/commands/code.ts

@@ -7,6 +7,8 @@ import { execa } from 'execa';
 import { Config } from '../utils/config.js';
 import { loadPatterns } from '../patterns/loader.js';
 import { runPatternCheck } from './check.js';
+import { textWithVoice, checkVoiceAvailability } from '../utils/voice.js';
+import { readClipboard, readFile, formatFilesForContext, looksLikePaste, handlePastedContent } from '../utils/files.js';
 
 interface CodeOptions {
   watch?: boolean;
@@ -82,11 +84,22 @@ export async function codeCommand(prompt?: string, options: CodeOptions = {}): P
     await processUserInput(prompt, messages, anthropic, systemPrompt, projectContext, config);
   }
 
+  // Check for voice support
+  const hasVoice = await checkVoiceAvailability();
+  
+  console.log(chalk.dim('  💡 Tips:'));
+  if (hasVoice) {
+    console.log(chalk.dim('     • Type "v" for voice input'));
+  }
+  console.log(chalk.dim('     • Type "clip" to read from clipboard'));
+  console.log(chalk.dim('     • Drag & drop files or paste file paths'));
+  console.log(chalk.dim('     • Paste code directly and I\'ll detect it\n'));
+
   // Interactive loop
   while (true) {
-    const input = await p.text({
+    const input = await textWithVoice({
       message: '',
-      placeholder: 'What do you want to build?',
+      placeholder: 'What do you want to build? (or paste code/file path)',
     });
 
     if (p.isCancel(input)) {
@@ -94,7 +107,8 @@ export async function codeCommand(prompt?: string, options: CodeOptions = {}): P
       break;
     }
 
-    const userInput = (input as string).trim();
+    let userInput = (input as string).trim();
+    let fileContext = '';
 
     if (!userInput) continue;
 
@@ -114,8 +128,91 @@ export async function codeCommand(prompt?: string, options: CodeOptions = {}): P
       continue;
     }
 
-    // Process input with AI
-    await processUserInput(userInput, messages, anthropic, systemPrompt, projectContext, config);
+    // Check for clipboard command
+    if (userInput.toLowerCase() === 'clip' || userInput.toLowerCase() === 'clipboard' || userInput.toLowerCase() === 'paste') {
+      const clipContent = await readClipboard();
+      if (clipContent) {
+        console.log(chalk.green(`\n📋 Read ${clipContent.length} characters from clipboard\n`));
+        
+        // Check if clipboard is a file path
+        if (await fs.pathExists(clipContent.trim())) {
+          const file = await readFile(clipContent.trim());
+          if (file) {
+            fileContext = formatFilesForContext([file]);
+            console.log(chalk.green(`📄 Loaded file: ${file.name}\n`));
+            
+            const instruction = await p.text({
+              message: `What should I do with ${file.name}?`,
+              placeholder: 'Fix any issues in this code',
+            });
+            if (p.isCancel(instruction)) continue;
+            userInput = instruction as string;
+          }
+        } else {
+          // Clipboard contains code/text
+          fileContext = `\n\n--- CLIPBOARD CONTENT ---\n\`\`\`\n${clipContent}\n\`\`\`\n--- END ---\n\n`;
+          
+          const action = await p.select({
+            message: 'What should I do with this?',
+            options: [
+              { value: 'analyze', label: '🔍 Analyze this' },
+              { value: 'fix', label: '🔧 Fix issues' },
+              { value: 'explain', label: '📖 Explain' },
+              { value: 'improve', label: '✨ Improve' },
+              { value: 'custom', label: '✏️  Custom' },
+            ],
+          });
+          
+          if (p.isCancel(action)) continue;
+          
+          if (action === 'custom') {
+            const custom = await p.text({ message: 'What should I do?', placeholder: 'Add TypeScript types' });
+            if (p.isCancel(custom)) continue;
+            userInput = custom as string;
+          } else {
+            const actions: Record<string, string> = {
+              analyze: 'Analyze this code and explain what it does',
+              fix: 'Fix any bugs or issues in this code',
+              explain: 'Explain this code step by step',
+              improve: 'Improve and refactor this code',
+            };
+            userInput = actions[action as string];
+          }
+        }
+      } else {
+        console.log(chalk.yellow('Clipboard is empty'));
+        continue;
+      }
+    }
+    
+    // Check if input is a file path
+    else if (await fs.pathExists(userInput)) {
+      const file = await readFile(userInput);
+      if (file) {
+        fileContext = formatFilesForContext([file]);
+        console.log(chalk.green(`\n📄 Loaded file: ${file.name}\n`));
+        
+        const instruction = await p.text({
+          message: `What should I do with ${file.name}?`,
+          placeholder: 'Analyze and improve this code',
+        });
+        if (p.isCancel(instruction)) continue;
+        userInput = instruction as string;
+      }
+    }
+    
+    // Check if input looks like pasted code
+    else if (looksLikePaste(userInput)) {
+      const result = await handlePastedContent(userInput);
+      if (result) {
+        userInput = result.prompt;
+        fileContext = result.context;
+      }
+    }
+
+    // Process input with AI (include file context if any)
+    const fullInput = fileContext ? userInput + fileContext : userInput;
+    await processUserInput(fullInput, messages, anthropic, systemPrompt, projectContext, config);
   }
 }
 

package/src/commands/migrate.ts

@@ -0,0 +1,419 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { Config } from '../utils/config.js';
+
+interface MigrateOptions {
+  push?: boolean;
+  generate?: boolean;
+  status?: boolean;
+}
+
+export async function migrateCommand(options: MigrateOptions = {}): Promise<void> {
+  const config = new Config();
+
+  if (!config.isInProject()) {
+    p.log.error('Not in a CodeBakers project.');
+    return;
+  }
+
+  p.intro(chalk.bgCyan.black(' Database Migrations '));
+
+  // Detect migration tool
+  const migrationTool = await detectMigrationTool();
+  
+  if (!migrationTool) {
+    p.log.error('No migration tool detected. Supported: Drizzle, Prisma, Supabase CLI');
+    return;
+  }
+
+  p.log.info(`Detected: ${migrationTool}`);
+
+  const action = options.push ? 'push' : 
+                 options.generate ? 'generate' :
+                 options.status ? 'status' :
+                 await p.select({
+                   message: 'What do you want to do?',
+                   options: [
+                     { value: 'status', label: '📊 Check migration status' },
+                     { value: 'generate', label: '📝 Generate migration' },
+                     { value: 'push', label: '🚀 Push to database' },
+                     { value: 'pull', label: '⬇️  Pull from database' },
+                   ],
+                 });
+
+  if (p.isCancel(action)) return;
+
+  switch (action) {
+    case 'status':
+      await checkMigrationStatus(migrationTool);
+      break;
+    case 'generate':
+      await generateMigration(migrationTool);
+      break;
+    case 'push':
+      await pushMigration(migrationTool);
+      break;
+    case 'pull':
+      await pullSchema(migrationTool);
+      break;
+  }
+}
+
+async function detectMigrationTool(): Promise<string | null> {
+  const cwd = process.cwd();
+  
+  // Check for Drizzle
+  if (fs.existsSync(path.join(cwd, 'drizzle.config.ts')) ||
+      fs.existsSync(path.join(cwd, 'drizzle.config.js'))) {
+    return 'drizzle';
+  }
+  
+  // Check for Prisma
+  if (fs.existsSync(path.join(cwd, 'prisma', 'schema.prisma'))) {
+    return 'prisma';
+  }
+  
+  // Check for Supabase
+  if (fs.existsSync(path.join(cwd, 'supabase', 'migrations'))) {
+    return 'supabase';
+  }
+
+  // Check package.json for clues
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = await fs.readJson(pkgPath);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    
+    if (deps['drizzle-orm'] || deps['drizzle-kit']) return 'drizzle';
+    if (deps['prisma'] || deps['@prisma/client']) return 'prisma';
+  }
+
+  return null;
+}
+
+async function checkMigrationStatus(tool: string): Promise<void> {
+  const spinner = p.spinner();
+  spinner.start('Checking migration status...');
+
+  try {
+    let result;
+    switch (tool) {
+      case 'drizzle':
+        result = await execa('npx', ['drizzle-kit', 'check'], { cwd: process.cwd(), reject: false });
+        break;
+      case 'prisma':
+        result = await execa('npx', ['prisma', 'migrate', 'status'], { cwd: process.cwd(), reject: false });
+        break;
+      case 'supabase':
+        result = await execa('npx', ['supabase', 'migration', 'list'], { cwd: process.cwd(), reject: false });
+        break;
+    }
+
+    spinner.stop('Status check complete');
+    
+    if (result?.stdout) {
+      console.log(chalk.dim(result.stdout));
+    }
+    if (result?.stderr) {
+      console.log(chalk.yellow(result.stderr));
+    }
+  } catch (error) {
+    spinner.stop('Error checking status');
+    p.log.error(error instanceof Error ? error.message : 'Unknown error');
+  }
+}
+
+async function generateMigration(tool: string): Promise<void> {
+  const name = await p.text({
+    message: 'Migration name:',
+    placeholder: 'add_users_table',
+    validate: (v) => !v ? 'Name required' : undefined,
+  });
+
+  if (p.isCancel(name)) return;
+
+  const spinner = p.spinner();
+  spinner.start('Generating migration...');
+
+  try {
+    let result;
+    switch (tool) {
+      case 'drizzle':
+        result = await execa('npx', ['drizzle-kit', 'generate', '--name', name as string], { cwd: process.cwd(), reject: false });
+        break;
+      case 'prisma':
+        result = await execa('npx', ['prisma', 'migrate', 'dev', '--name', name as string, '--create-only'], { cwd: process.cwd(), reject: false });
+        break;
+      case 'supabase':
+        result = await execa('npx', ['supabase', 'migration', 'new', name as string], { cwd: process.cwd(), reject: false });
+        break;
+    }
+
+    spinner.stop('Migration generated');
+    
+    if (result?.stdout) {
+      console.log(chalk.dim(result.stdout));
+    }
+  } catch (error) {
+    spinner.stop('Error generating migration');
+    p.log.error(error instanceof Error ? error.message : 'Unknown error');
+  }
+}
+
+async function pushMigration(tool: string): Promise<void> {
+  const spinner = p.spinner();
+  spinner.start('Pushing migration to database...');
+
+  try {
+    let result;
+    let migrationSql = '';
+
+    switch (tool) {
+      case 'drizzle':
+        result = await execa('npx', ['drizzle-kit', 'push'], { 
+          cwd: process.cwd(), 
+          reject: false,
+          env: { ...process.env }
+        });
+        break;
+      case 'prisma':
+        result = await execa('npx', ['prisma', 'db', 'push'], { 
+          cwd: process.cwd(), 
+          reject: false 
+        });
+        break;
+      case 'supabase':
+        result = await execa('npx', ['supabase', 'db', 'push'], { 
+          cwd: process.cwd(), 
+          reject: false 
+        });
+        break;
+    }
+
+    // Check if push failed
+    if (result?.exitCode !== 0) {
+      spinner.stop('Migration push failed');
+      
+      const errorOutput = result?.stderr || result?.stdout || '';
+      console.log(chalk.red('\nError:\n'));
+      console.log(chalk.dim(errorOutput));
+
+      // Try to get the SQL that needs to be run
+      migrationSql = await extractMigrationSQL(tool, errorOutput);
+
+      if (migrationSql) {
+        // Copy to clipboard
+        const copied = await copyToClipboard(migrationSql);
+        
+        if (copied) {
+          console.log(chalk.green(`
+╔════════════════════════════════════════════════════════════════╗
+║  📋 MIGRATION SQL COPIED TO CLIPBOARD!                         ║
+╠════════════════════════════════════════════════════════════════╣
+║                                                                ║
+║  The migration could not be pushed automatically.              ║
+║  The SQL has been copied to your clipboard.                    ║
+║                                                                ║
+║  Next steps:                                                   ║
+║  1. Go to your Supabase Dashboard → SQL Editor                 ║
+║  2. Paste the SQL (Ctrl+V / Cmd+V)                            ║
+║  3. Review and run it                                          ║
+║                                                                ║
+╚════════════════════════════════════════════════════════════════╝
+`));
+
+          // Also show the SQL
+          const showSql = await p.confirm({
+            message: 'Show the SQL here too?',
+            initialValue: true,
+          });
+
+          if (showSql && !p.isCancel(showSql)) {
+            console.log(chalk.cyan('\n--- SQL Migration ---\n'));
+            console.log(migrationSql);
+            console.log(chalk.cyan('\n--- End SQL ---\n'));
+          }
+        } else {
+          // Clipboard failed, just show the SQL
+          console.log(chalk.yellow(`
+╔════════════════════════════════════════════════════════════════╗
+║  ⚠️  Could not copy to clipboard                               ║
+║                                                                ║
+║  Here's the SQL to run manually:                               ║
+╚════════════════════════════════════════════════════════════════╝
+`));
+          console.log(chalk.cyan(migrationSql));
+        }
+
+        // Save to file as backup
+        const sqlPath = path.join(process.cwd(), '.codebakers', 'failed-migration.sql');
+        await fs.ensureDir(path.dirname(sqlPath));
+        await fs.writeFile(sqlPath, migrationSql);
+        console.log(chalk.dim(`\nAlso saved to: ${sqlPath}\n`));
+
+      } else {
+        p.log.error('Could not extract migration SQL. Check the error above.');
+      }
+
+      return;
+    }
+
+    spinner.stop('Migration pushed successfully!');
+    
+    if (result?.stdout) {
+      console.log(chalk.dim(result.stdout));
+    }
+
+    p.log.success('Database updated!');
+
+  } catch (error) {
+    spinner.stop('Error');
+    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+    p.log.error(errorMsg);
+
+    // Try to extract and copy SQL even from exception
+    const migrationSql = await extractMigrationSQL(tool, errorMsg);
+    if (migrationSql) {
+      await copyToClipboard(migrationSql);
+      console.log(chalk.green('\n📋 Migration SQL copied to clipboard!\n'));
+      console.log(chalk.cyan(migrationSql));
+    }
+  }
+}
+
+async function pullSchema(tool: string): Promise<void> {
+  const spinner = p.spinner();
+  spinner.start('Pulling schema from database...');
+
+  try {
+    let result;
+    switch (tool) {
+      case 'drizzle':
+        result = await execa('npx', ['drizzle-kit', 'introspect'], { cwd: process.cwd(), reject: false });
+        break;
+      case 'prisma':
+        result = await execa('npx', ['prisma', 'db', 'pull'], { cwd: process.cwd(), reject: false });
+        break;
+      case 'supabase':
+        result = await execa('npx', ['supabase', 'db', 'pull'], { cwd: process.cwd(), reject: false });
+        break;
+    }
+
+    spinner.stop('Schema pulled');
+    
+    if (result?.stdout) {
+      console.log(chalk.dim(result.stdout));
+    }
+  } catch (error) {
+    spinner.stop('Error pulling schema');
+    p.log.error(error instanceof Error ? error.message : 'Unknown error');
+  }
+}
+
+async function extractMigrationSQL(tool: string, errorOutput: string): Promise<string | null> {
+  const cwd = process.cwd();
+
+  try {
+    switch (tool) {
+      case 'drizzle': {
+        // Check for pending migrations in drizzle folder
+        const drizzleDir = path.join(cwd, 'drizzle');
+        if (fs.existsSync(drizzleDir)) {
+          const files = await fs.readdir(drizzleDir);
+          const sqlFiles = files.filter(f => f.endsWith('.sql')).sort().reverse();
+          if (sqlFiles.length > 0) {
+            const latestMigration = await fs.readFile(path.join(drizzleDir, sqlFiles[0]), 'utf-8');
+            return latestMigration;
+          }
+        }
+        
+        // Try to generate SQL
+        const result = await execa('npx', ['drizzle-kit', 'generate', '--sql'], { 
+          cwd, 
+          reject: false 
+        });
+        if (result?.stdout) {
+          // Extract SQL from output
+          const sqlMatch = result.stdout.match(/```sql([\s\S]*?)```/);
+          if (sqlMatch) return sqlMatch[1].trim();
+          return result.stdout;
+        }
+        break;
+      }
+
+      case 'prisma': {
+        // Check for pending migrations
+        const migrationsDir = path.join(cwd, 'prisma', 'migrations');
+        if (fs.existsSync(migrationsDir)) {
+          const migrations = await fs.readdir(migrationsDir);
+          const sorted = migrations.filter(m => m !== 'migration_lock.toml').sort().reverse();
+          if (sorted.length > 0) {
+            const migrationPath = path.join(migrationsDir, sorted[0], 'migration.sql');
+            if (fs.existsSync(migrationPath)) {
+              return await fs.readFile(migrationPath, 'utf-8');
+            }
+          }
+        }
+        break;
+      }
+
+      case 'supabase': {
+        // Check supabase migrations folder
+        const migrationsDir = path.join(cwd, 'supabase', 'migrations');
+        if (fs.existsSync(migrationsDir)) {
+          const files = await fs.readdir(migrationsDir);
+          const sqlFiles = files.filter(f => f.endsWith('.sql')).sort().reverse();
+          if (sqlFiles.length > 0) {
+            return await fs.readFile(path.join(migrationsDir, sqlFiles[0]), 'utf-8');
+          }
+        }
+        break;
+      }
+    }
+
+    // Try to extract SQL from error message itself
+    const sqlMatch = errorOutput.match(/(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE)[\s\S]+?;/gi);
+    if (sqlMatch) {
+      return sqlMatch.join('\n\n');
+    }
+
+  } catch {
+    // Silent fail
+  }
+
+  return null;
+}
+
+async function copyToClipboard(text: string): Promise<boolean> {
+  try {
+    // Try different clipboard methods based on OS
+    const platform = process.platform;
+
+    if (platform === 'win32') {
+      // Windows: use clip command
+      const proc = await execa('clip', { input: text, reject: false });
+      return proc.exitCode === 0;
+    } else if (platform === 'darwin') {
+      // macOS: use pbcopy
+      const proc = await execa('pbcopy', { input: text, reject: false });
+      return proc.exitCode === 0;
+    } else {
+      // Linux: try xclip or xsel
+      try {
+        const proc = await execa('xclip', ['-selection', 'clipboard'], { input: text, reject: false });
+        return proc.exitCode === 0;
+      } catch {
+        const proc = await execa('xsel', ['--clipboard', '--input'], { input: text, reject: false });
+        return proc.exitCode === 0;
+      }
+    }
+  } catch {
+    return false;
+  }
+}
+
+// Export for use in other commands
+export { copyToClipboard, extractMigrationSQL };