codebakers 1.0.45 → 2.0.0

package/src/commands/deploy.ts

@@ -0,0 +1,414 @@
+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 Anthropic from '@anthropic-ai/sdk';
+import { Config } from '../utils/config.js';
+import { VercelService } from '../services/vercel.js';
+import { runPatternCheck } from './check.js';
+
+interface DeployOptions {
+  preview?: boolean;
+  check?: boolean;
+}
+
+export async function deployCommand(options: DeployOptions = {}): Promise<void> {
+  const config = new Config();
+
+  if (!config.isInProject()) {
+    p.log.error('Not in a CodeBakers project.');
+    return;
+  }
+
+  p.intro(chalk.bgCyan.black(' Deploy to Production '));
+
+  const spinner = p.spinner();
+
+  // Step 1: Run pattern check (unless skipped)
+  if (options.check !== false) {
+    spinner.start('Running CodeBakers check...');
+    const checkResult = await runPatternCheck(false);
+    
+    if (!checkResult.passed) {
+      spinner.stop('');
+      const errors = checkResult.violations.filter(v => v.severity === 'error');
+      
+      if (errors.length > 0) {
+        p.log.error(`${errors.length} pattern violations found. Fix before deploying.`);
+        
+        const showViolations = await p.confirm({
+          message: 'Show violations?',
+          initialValue: true,
+        });
+
+        if (showViolations && !p.isCancel(showViolations)) {
+          for (const v of errors) {
+            console.log(chalk.red(`  ✗ ${v.file}:${v.line} - ${v.message}`));
+          }
+        }
+
+        const autoFix = await p.confirm({
+          message: 'Attempt auto-fix with AI?',
+          initialValue: true,
+        });
+
+        if (!autoFix || p.isCancel(autoFix)) {
+          p.outro(chalk.red('Deploy cancelled.'));
+          return;
+        }
+
+        // Auto-fix with AI
+        spinner.start('Auto-fixing with AI...');
+        await autoFixWithAI(config, errors);
+        spinner.stop('Auto-fix complete');
+
+        // Re-run check
+        const recheck = await runPatternCheck(false);
+        if (!recheck.passed) {
+          p.log.error('Some violations remain. Manual fix required.');
+          p.outro(chalk.red('Deploy cancelled.'));
+          return;
+        }
+      }
+    }
+    spinner.stop('Pattern check passed');
+  }
+
+  // Step 2: Run TypeScript check
+  spinner.start('Running TypeScript check...');
+  try {
+    await execa('npx', ['tsc', '--noEmit'], { cwd: process.cwd() });
+    spinner.stop('TypeScript check passed');
+  } catch (error) {
+    spinner.stop('');
+    p.log.error('TypeScript errors found.');
+    
+    const fix = await p.confirm({
+      message: 'Attempt to fix TypeScript errors?',
+      initialValue: true,
+    });
+
+    if (fix && !p.isCancel(fix)) {
+      spinner.start('Fixing TypeScript errors...');
+      const fixed = await fixTypeScriptErrors(config);
+      spinner.stop(fixed ? 'TypeScript errors fixed' : 'Could not auto-fix all errors');
+      
+      if (!fixed) {
+        p.outro(chalk.red('Deploy cancelled.'));
+        return;
+      }
+    } else {
+      p.outro(chalk.red('Deploy cancelled.'));
+      return;
+    }
+  }
+
+  // Step 3: Run build
+  spinner.start('Building project...');
+  try {
+    await execa('pnpm', ['build'], { cwd: process.cwd() });
+    spinner.stop('Build successful');
+  } catch (error) {
+    spinner.stop('');
+    p.log.error('Build failed.');
+    
+    const errorOutput = error instanceof Error ? error.message : 'Unknown error';
+    console.log(chalk.dim(errorOutput));
+
+    const fix = await p.confirm({
+      message: 'Attempt to fix build errors with AI?',
+      initialValue: true,
+    });
+
+    if (fix && !p.isCancel(fix)) {
+      spinner.start('Fixing build errors...');
+      const fixed = await fixBuildErrors(config, errorOutput);
+      spinner.stop(fixed ? 'Build errors fixed' : 'Could not auto-fix');
+      
+      if (fixed) {
+        // Retry build
+        spinner.start('Retrying build...');
+        try {
+          await execa('pnpm', ['build'], { cwd: process.cwd() });
+          spinner.stop('Build successful');
+        } catch {
+          spinner.stop('Build still failing');
+          p.outro(chalk.red('Deploy cancelled.'));
+          return;
+        }
+      } else {
+        p.outro(chalk.red('Deploy cancelled.'));
+        return;
+      }
+    } else {
+      p.outro(chalk.red('Deploy cancelled.'));
+      return;
+    }
+  }
+
+  // Step 4: Git commit if there are changes
+  spinner.start('Checking for uncommitted changes...');
+  const { stdout: gitStatus } = await execa('git', ['status', '--porcelain'], { cwd: process.cwd() });
+  
+  if (gitStatus.trim()) {
+    spinner.stop('');
+    const commit = await p.confirm({
+      message: 'You have uncommitted changes. Commit before deploying?',
+      initialValue: true,
+    });
+
+    if (commit && !p.isCancel(commit)) {
+      const message = await p.text({
+        message: 'Commit message:',
+        placeholder: 'Pre-deploy changes',
+        initialValue: 'Pre-deploy changes',
+      });
+
+      if (!p.isCancel(message)) {
+        await execa('git', ['add', '.'], { cwd: process.cwd() });
+        await execa('git', ['commit', '-m', message as string], { cwd: process.cwd() });
+        
+        spinner.start('Pushing to GitHub...');
+        await execa('git', ['push'], { cwd: process.cwd() });
+        spinner.stop('Pushed to GitHub');
+      }
+    }
+  } else {
+    spinner.stop('No uncommitted changes');
+  }
+
+  // Step 5: Deploy to Vercel
+  const deployType = options.preview ? 'preview' : 'production';
+  spinner.start(`Deploying to ${deployType}...`);
+
+  try {
+    const vercel = new VercelService(config);
+    const deployment = await vercel.deploy(process.cwd(), !options.preview);
+    
+    spinner.stop('Deployment complete!');
+
+    console.log(boxedOutput(`
+${chalk.green('✓')} Deployed successfully!
+
+${chalk.bold('URL:')} ${deployment.url}
+${chalk.bold('Type:')} ${deployType}
+${chalk.bold('Time:')} ${new Date().toLocaleTimeString()}
+
+${chalk.dim('View in Vercel Dashboard:')}
+${chalk.dim(deployment.dashboardUrl || 'https://vercel.com/dashboard')}
+`));
+
+  } catch (error) {
+    spinner.stop('');
+    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+    p.log.error(`Deployment failed: ${errorMsg}`);
+
+    // Check if it's a build error from Vercel
+    if (errorMsg.includes('Build failed')) {
+      const retry = await p.confirm({
+        message: 'Attempt to fix and retry?',
+        initialValue: true,
+      });
+
+      if (retry && !p.isCancel(retry)) {
+        spinner.start('Analyzing Vercel build error...');
+        // Would fetch Vercel logs and auto-fix
+        spinner.stop('Fix attempted');
+      }
+    }
+
+    p.outro(chalk.red('Deploy failed.'));
+  }
+}
+
+async function autoFixWithAI(
+  config: Config,
+  violations: Array<{ file: string; line: number; rule: string; message: string }>
+): Promise<void> {
+  const anthropicCreds = config.getCredentials('anthropic');
+  if (!anthropicCreds?.apiKey) {
+    throw new Error('Anthropic API key not configured');
+  }
+
+  const anthropic = new Anthropic({
+    apiKey: anthropicCreds.apiKey,
+  });
+
+  // Group by file
+  const byFile = new Map<string, typeof violations>();
+  for (const v of violations) {
+    if (!byFile.has(v.file)) {
+      byFile.set(v.file, []);
+    }
+    byFile.get(v.file)!.push(v);
+  }
+
+  for (const [file, fileViolations] of byFile) {
+    const filePath = path.join(process.cwd(), file);
+    const content = await fs.readFile(filePath, 'utf-8');
+
+    const prompt = `Fix these CodeBakers pattern violations in this file:
+
+Violations:
+${fileViolations.map(v => `- Line ${v.line}: ${v.rule} - ${v.message}`).join('\n')}
+
+Current file content:
+\`\`\`typescript
+${content}
+\`\`\`
+
+Output ONLY the corrected file content, no explanations. Keep all existing functionality.`;
+
+    const response = await anthropic.messages.create({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 8192,
+      messages: [{ role: 'user', content: prompt }],
+    });
+
+    let fixed = response.content[0].type === 'text' ? response.content[0].text : '';
+    
+    // Extract code from markdown if present
+    const codeMatch = fixed.match(/```(?:typescript|tsx?)?\n([\s\S]+?)\n```/);
+    if (codeMatch) {
+      fixed = codeMatch[1];
+    }
+
+    await fs.writeFile(filePath, fixed);
+  }
+}
+
+async function fixTypeScriptErrors(config: Config): Promise<boolean> {
+  try {
+    // Get TypeScript errors
+    const { stderr } = await execa('npx', ['tsc', '--noEmit'], { 
+      cwd: process.cwd(),
+      reject: false,
+    });
+
+    if (!stderr) return true;
+
+    const anthropicCreds = config.getCredentials('anthropic');
+    if (!anthropicCreds?.apiKey) {
+      return false;
+    }
+
+    const anthropic = new Anthropic({
+      apiKey: anthropicCreds.apiKey,
+    });
+
+    // Parse error locations
+    const errorLines = stderr.split('\n').filter(line => line.includes('error TS'));
+    
+    for (const errorLine of errorLines.slice(0, 10)) { // Limit to 10 errors
+      const match = errorLine.match(/^(.+?)\((\d+),(\d+)\): error (TS\d+): (.+)$/);
+      if (!match) continue;
+
+      const [, file, line, , , message] = match;
+      const filePath = path.join(process.cwd(), file);
+      
+      if (!await fs.pathExists(filePath)) continue;
+
+      const content = await fs.readFile(filePath, 'utf-8');
+
+      const prompt = `Fix this TypeScript error:
+
+File: ${file}
+Line: ${line}
+Error: ${message}
+
+Current file content:
+\`\`\`typescript
+${content}
+\`\`\`
+
+Output ONLY the corrected file content, no explanations.`;
+
+      const response = await anthropic.messages.create({
+        model: 'claude-sonnet-4-20250514',
+        max_tokens: 8192,
+        messages: [{ role: 'user', content: prompt }],
+      });
+
+      let fixed = response.content[0].type === 'text' ? response.content[0].text : '';
+      
+      const codeMatch = fixed.match(/```(?:typescript|tsx?)?\n([\s\S]+?)\n```/);
+      if (codeMatch) {
+        fixed = codeMatch[1];
+      }
+
+      await fs.writeFile(filePath, fixed);
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function fixBuildErrors(config: Config, errorOutput: string): Promise<boolean> {
+  const anthropicCreds = config.getCredentials('anthropic');
+  if (!anthropicCreds?.apiKey) {
+    return false;
+  }
+
+  const anthropic = new Anthropic({
+    apiKey: anthropicCreds.apiKey,
+  });
+
+  // Parse error to find file
+  const fileMatch = errorOutput.match(/(?:Error|error).*?(?:in|at)\s+(.+?\.tsx?)(?::|$)/);
+  if (!fileMatch) return false;
+
+  const file = fileMatch[1];
+  const filePath = path.join(process.cwd(), file);
+  
+  if (!await fs.pathExists(filePath)) return false;
+
+  const content = await fs.readFile(filePath, 'utf-8');
+
+  const prompt = `Fix this build error:
+
+Error output:
+${errorOutput}
+
+File: ${file}
+
+Current file content:
+\`\`\`typescript
+${content}
+\`\`\`
+
+Output ONLY the corrected file content, no explanations.`;
+
+  try {
+    const response = await anthropic.messages.create({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 8192,
+      messages: [{ role: 'user', content: prompt }],
+    });
+
+    let fixed = response.content[0].type === 'text' ? response.content[0].text : '';
+    
+    const codeMatch = fixed.match(/```(?:typescript|tsx?)?\n([\s\S]+?)\n```/);
+    if (codeMatch) {
+      fixed = codeMatch[1];
+    }
+
+    await fs.writeFile(filePath, fixed);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function boxedOutput(content: string): string {
+  const lines = content.split('\n');
+  const maxLength = Math.max(...lines.map(l => l.replace(/\x1b\[[0-9;]*m/g, '').length));
+  const border = '─'.repeat(maxLength + 2);
+  
+  return `
+╭${border}╮
+${lines.map(l => `│ ${l.padEnd(maxLength)} │`).join('\n')}
+╰${border}╯`;
+}

package/src/commands/fix.ts

@@ -0,0 +1,20 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { runPatternCheck } from './check.js';
+
+export async function fixCommand(): Promise<void> {
+  p.intro(chalk.bgCyan.black(' Auto-Fix '));
+
+  const spinner = p.spinner();
+  spinner.start('Analyzing code...');
+
+  const result = await runPatternCheck(true);
+
+  if (result.passed) {
+    spinner.stop('No issues found!');
+  } else {
+    spinner.stop(`Fixed ${result.violations.length} issues`);
+  }
+
+  p.outro(chalk.green('Done!'));
+}