codebakers 2.0.2 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebakers",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "AI dev team that follows the rules. Build apps from anywhere with pattern enforcement.",
   "type": "module",
   "main": "dist/index.js",

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 };

package/src/index.ts

@@ -22,6 +22,7 @@ import { fixCommand } from './commands/fix.js';
 import { designCommand } from './commands/design.js';
 import { prdCommand } from './commands/prd.js';
 import { advisorsCommand } from './commands/advisors.js';
+import { migrateCommand } from './commands/migrate.js';
 
 const VERSION = '1.0.0';
 
@@ -64,6 +65,7 @@ async function showMainMenu(): Promise<void> {
       { value: 'code', label: '💬 Code with AI', hint: 'build features, fix bugs' },
       { value: 'check', label: '🔍 Check code quality', hint: 'run pattern enforcement' },
       { value: 'deploy', label: '🚀 Deploy', hint: 'deploy to Vercel' },
+      { value: 'migrate', label: '🗄️  Database migrations', hint: 'push, generate, status' },
       { value: 'fix', label: '🔧 Fix errors', hint: 'auto-fix build/deploy errors' },
       { value: 'generate', label: '⚡ Generate', hint: 'scaffold components, pages' },
       { value: 'status', label: '📊 Project status', hint: 'view project health' },
@@ -110,6 +112,9 @@ async function showMainMenu(): Promise<void> {
     case 'deploy':
       await deployCommand();
       break;
+    case 'migrate':
+      await migrateCommand();
+      break;
     case 'fix':
       await fixCommand();
       break;
@@ -287,6 +292,15 @@ program
   .description('Consult with the CodeBakers Dream Team advisory board')
   .action(advisorsCommand);
 
+program
+  .command('migrate')
+  .alias('db')
+  .description('Database migrations (push, generate, status)')
+  .option('--push', 'Push migrations to database')
+  .option('--generate', 'Generate new migration')
+  .option('--status', 'Check migration status')
+  .action(migrateCommand);
+
 // Parse args or show menu
 const args = process.argv.slice(2);
 

package/src/utils/config.ts

@@ -141,7 +141,99 @@ export class Config {
     const cwd = process.cwd();
     const codebakersDir = path.join(cwd, '.codebakers');
     const claudeFile = path.join(cwd, 'CLAUDE.md');
-    return fs.existsSync(codebakersDir) || fs.existsSync(claudeFile);
+    
+    // Already a CodeBakers project
+    if (fs.existsSync(codebakersDir) || fs.existsSync(claudeFile)) {
+      return true;
+    }
+    
+    // Auto-detect existing projects by common files
+    const projectIndicators = [
+      'package.json',
+      'next.config.js',
+      'next.config.mjs', 
+      'next.config.ts',
+      'vite.config.ts',
+      'vite.config.js',
+      'remix.config.js',
+      'astro.config.mjs',
+    ];
+    
+    const hasProjectFile = projectIndicators.some(file => 
+      fs.existsSync(path.join(cwd, file))
+    );
+    
+    // If it's a project but no .codebakers, auto-initialize
+    if (hasProjectFile) {
+      this.autoInitExisting(cwd);
+      return true;
+    }
+    
+    return false;
+  }
+
+  // Auto-initialize CodeBakers in an existing project
+  private autoInitExisting(cwd: string): void {
+    try {
+      // Detect framework
+      let framework = 'unknown';
+      let ui = 'unknown';
+      
+      if (fs.existsSync(path.join(cwd, 'next.config.js')) || 
+          fs.existsSync(path.join(cwd, 'next.config.mjs')) ||
+          fs.existsSync(path.join(cwd, 'next.config.ts'))) {
+        framework = 'nextjs';
+      } else if (fs.existsSync(path.join(cwd, 'vite.config.ts')) ||
+                 fs.existsSync(path.join(cwd, 'vite.config.js'))) {
+        framework = 'vite';
+      } else if (fs.existsSync(path.join(cwd, 'remix.config.js'))) {
+        framework = 'remix';
+      } else if (fs.existsSync(path.join(cwd, 'astro.config.mjs'))) {
+        framework = 'astro';
+      }
+
+      // Check for UI libraries in package.json
+      const pkgPath = path.join(cwd, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        const pkg = fs.readJsonSync(pkgPath);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        
+        if (deps['@shadcn/ui'] || deps['class-variance-authority']) {
+          ui = 'shadcn';
+        } else if (deps['@chakra-ui/react']) {
+          ui = 'chakra';
+        } else if (deps['@mantine/core']) {
+          ui = 'mantine';
+        } else if (deps['@mui/material']) {
+          ui = 'mui';
+        }
+      }
+
+      // Create .codebakers config
+      const configDir = path.join(cwd, '.codebakers');
+      fs.ensureDirSync(configDir);
+      
+      const config = {
+        name: path.basename(cwd),
+        framework,
+        ui,
+        createdAt: new Date().toISOString(),
+        autoDetected: true,
+      };
+      
+      fs.writeJsonSync(path.join(configDir, 'config.json'), config, { spaces: 2 });
+
+      // Add to .gitignore if exists
+      const gitignorePath = path.join(cwd, '.gitignore');
+      if (fs.existsSync(gitignorePath)) {
+        const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+        if (!gitignore.includes('.codebakers')) {
+          fs.appendFileSync(gitignorePath, '\n# CodeBakers\n.codebakers/\n');
+        }
+      }
+    } catch {
+      // Silent fail - don't block if auto-init fails
+    }
   }
 
   // Get current project config