codebakers 1.0.45 → 2.0.1

package/src/commands/code.ts

@@ -0,0 +1,684 @@
+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 { execa } from 'execa';
+import { Config } from '../utils/config.js';
+import { loadPatterns } from '../patterns/loader.js';
+import { runPatternCheck } from './check.js';
+
+interface CodeOptions {
+  watch?: boolean;
+}
+
+interface Message {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+interface ProjectContext {
+  name: string;
+  framework: string;
+  ui: string;
+  packages: string[];
+  existingFiles: string[];
+  recentChanges: string[];
+}
+
+export async function codeCommand(prompt?: string, options: CodeOptions = {}): Promise<void> {
+  const config = new Config();
+
+  // Check if configured
+  if (!config.isConfigured()) {
+    p.log.error('Please run `codebakers setup` first.');
+    return;
+  }
+
+  // Check if in project
+  if (!config.isInProject()) {
+    p.log.error('Not in a CodeBakers project. Run `codebakers init` first.');
+    return;
+  }
+
+  // Get API key
+  const anthropicCreds = config.getCredentials('anthropic');
+  if (!anthropicCreds?.apiKey) {
+    p.log.error('Anthropic API key not configured. Run `codebakers setup`.');
+    return;
+  }
+
+  // Initialize Anthropic
+  const anthropic = new Anthropic({
+    apiKey: anthropicCreds.apiKey,
+  });
+
+  // Load project context
+  const projectContext = await loadProjectContext();
+  
+  // Load patterns
+  const patterns = await loadPatterns(config);
+
+  // Build system prompt
+  const systemPrompt = buildSystemPrompt(projectContext, patterns);
+
+  console.log(chalk.cyan(`
+╭─────────────────────────────────────────────────────╮
+│  🤖 CodeBakers AI                                   │
+│                                                     │
+│  Project: ${projectContext.name.padEnd(38)}│
+│  Stack: ${`${projectContext.framework} + ${projectContext.ui}`.padEnd(40)}│
+│                                                     │
+│  Type your request or "?" for help                  │
+│  Type "exit" or Ctrl+C to quit                      │
+╰─────────────────────────────────────────────────────╯
+`));
+
+  // Conversation history
+  const messages: Message[] = [];
+
+  // If prompt provided via command line
+  if (prompt) {
+    await processUserInput(prompt, messages, anthropic, systemPrompt, projectContext, config);
+  }
+
+  // Interactive loop
+  while (true) {
+    const input = await p.text({
+      message: '',
+      placeholder: 'What do you want to build?',
+    });
+
+    if (p.isCancel(input)) {
+      p.outro('Goodbye!');
+      break;
+    }
+
+    const userInput = (input as string).trim();
+
+    if (!userInput) continue;
+
+    if (userInput.toLowerCase() === 'exit') {
+      p.outro('Goodbye!');
+      break;
+    }
+
+    if (userInput === '?') {
+      showHelp();
+      continue;
+    }
+
+    // Handle slash commands
+    if (userInput.startsWith('/')) {
+      await handleSlashCommand(userInput, projectContext, config);
+      continue;
+    }
+
+    // Process input with AI
+    await processUserInput(userInput, messages, anthropic, systemPrompt, projectContext, config);
+  }
+}
+
+async function processUserInput(
+  userInput: string,
+  messages: Message[],
+  anthropic: Anthropic,
+  systemPrompt: string,
+  projectContext: ProjectContext,
+  config: Config
+): Promise<void> {
+  const spinner = p.spinner();
+
+  // Add user message
+  messages.push({ role: 'user', content: userInput });
+
+  // Check for wizard triggers
+  const wizardResult = await checkForWizard(userInput);
+  if (wizardResult) {
+    // If wizard ran, use its enhanced prompt
+    messages[messages.length - 1].content = wizardResult;
+  }
+
+  try {
+    spinner.start('Thinking...');
+
+    // Call Claude
+    const response = await anthropic.messages.create({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 8192,
+      system: systemPrompt,
+      messages: messages.map(m => ({
+        role: m.role,
+        content: m.content,
+      })),
+    });
+
+    spinner.stop('');
+
+    // Extract response
+    const assistantMessage = response.content[0].type === 'text' 
+      ? response.content[0].text 
+      : '';
+
+    // Add to history
+    messages.push({ role: 'assistant', content: assistantMessage });
+
+    // Parse and execute any code actions
+    const actions = parseActions(assistantMessage);
+    
+    if (actions.length > 0) {
+      // Show plan
+      console.log(chalk.cyan('\n📋 Plan:'));
+      actions.forEach((action, i) => {
+        console.log(chalk.dim(`  ${i + 1}. ${action.description}`));
+      });
+      console.log('');
+
+      const proceed = await p.confirm({
+        message: 'Execute this plan?',
+        initialValue: true,
+      });
+
+      if (proceed && !p.isCancel(proceed)) {
+        spinner.start('Building...');
+        
+        for (const action of actions) {
+          await executeAction(action, spinner);
+        }
+
+        spinner.stop('Build complete');
+
+        // Run pattern check
+        console.log(chalk.dim('\n🔍 Running CodeBakers check...'));
+        const checkResult = await runPatternCheck(false);
+        
+        if (checkResult.violations.length > 0) {
+          console.log(chalk.yellow(`\n⚠️  ${checkResult.violations.length} pattern violations found`));
+          
+          const autoFix = await p.confirm({
+            message: 'Auto-fix violations?',
+            initialValue: true,
+          });
+
+          if (autoFix && !p.isCancel(autoFix)) {
+            spinner.start('Auto-fixing...');
+            await autoFixViolations(checkResult.violations, anthropic, systemPrompt);
+            spinner.stop('Violations fixed');
+          }
+        } else {
+          console.log(chalk.green('✓ All patterns satisfied'));
+        }
+
+        // Update project context
+        projectContext.recentChanges.push(...actions.map(a => a.description));
+      }
+    } else {
+      // Just print the response
+      console.log('\n' + assistantMessage + '\n');
+    }
+
+  } catch (error) {
+    spinner.stop('Error');
+    console.log(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+  }
+}
+
+function buildSystemPrompt(context: ProjectContext, patterns: string): string {
+  return `You are CodeBakers, an AI coding assistant that ALWAYS follows the user's patterns and rules.
+
+PROJECT CONTEXT:
+- Name: ${context.name}
+- Framework: ${context.framework}
+- UI Library: ${context.ui}
+- Packages: ${context.packages.join(', ')}
+
+EXISTING FILES:
+${context.existingFiles.slice(0, 50).join('\n')}
+
+RECENT CHANGES:
+${context.recentChanges.slice(-10).join('\n')}
+
+CODEBAKERS PATTERNS (MUST FOLLOW):
+${patterns}
+
+INSTRUCTIONS:
+1. ALWAYS follow the patterns above - they are non-negotiable
+2. When creating code, output it in this format:
+   
+   <<<ACTION:CREATE_FILE>>>
+   PATH: src/path/to/file.tsx
+   DESCRIPTION: Brief description
+   <<<CONTENT>>>
+   // file content here
+   <<<END_CONTENT>>>
+   <<<END_ACTION>>>
+
+3. For editing files:
+   
+   <<<ACTION:EDIT_FILE>>>
+   PATH: src/path/to/file.tsx
+   DESCRIPTION: What you're changing
+   <<<FIND>>>
+   // code to find
+   <<<REPLACE>>>
+   // replacement code
+   <<<END_ACTION>>>
+
+4. For running commands:
+   
+   <<<ACTION:RUN_COMMAND>>>
+   COMMAND: pnpm add some-package
+   DESCRIPTION: Why running this
+   <<<END_ACTION>>>
+
+5. Every button MUST have a working onClick handler
+6. Every form MUST have proper validation with Zod
+7. Every async operation MUST have loading, error, and success states
+8. Every list MUST have empty state handling
+9. Use Zustand for state management, not prop drilling
+10. Put files in the correct folders as specified in patterns
+
+If you're unsure about requirements, ask clarifying questions before coding.
+`;
+}
+
+async function loadProjectContext(): Promise<ProjectContext> {
+  const cwd = process.cwd();
+  const codebakersConfig = path.join(cwd, '.codebakers', 'config.json');
+  
+  let projectConfig: Record<string, unknown> = {};
+  if (await fs.pathExists(codebakersConfig)) {
+    projectConfig = await fs.readJson(codebakersConfig);
+  }
+
+  // Get list of files
+  const glob = (await import('fast-glob')).default;
+  const files = await glob(['src/**/*.{ts,tsx,js,jsx}'], { cwd });
+
+  return {
+    name: path.basename(cwd),
+    framework: (projectConfig.framework as string) || 'nextjs',
+    ui: (projectConfig.ui as string) || 'shadcn',
+    packages: (projectConfig.packages as string[]) || [],
+    existingFiles: files,
+    recentChanges: [],
+  };
+}
+
+interface CodeAction {
+  type: 'CREATE_FILE' | 'EDIT_FILE' | 'RUN_COMMAND' | 'DELETE_FILE';
+  path?: string;
+  content?: string;
+  command?: string;
+  description: string;
+  find?: string;
+  replace?: string;
+}
+
+function parseActions(response: string): CodeAction[] {
+  const actions: CodeAction[] = [];
+  
+  // Parse CREATE_FILE actions
+  const createFileRegex = /<<<ACTION:CREATE_FILE>>>\s*PATH:\s*(.+?)\s*DESCRIPTION:\s*(.+?)\s*<<<CONTENT>>>\s*([\s\S]+?)\s*<<<END_CONTENT>>>\s*<<<END_ACTION>>>/g;
+  let match;
+  
+  while ((match = createFileRegex.exec(response)) !== null) {
+    actions.push({
+      type: 'CREATE_FILE',
+      path: match[1].trim(),
+      description: match[2].trim(),
+      content: match[3].trim(),
+    });
+  }
+
+  // Parse EDIT_FILE actions
+  const editFileRegex = /<<<ACTION:EDIT_FILE>>>\s*PATH:\s*(.+?)\s*DESCRIPTION:\s*(.+?)\s*<<<FIND>>>\s*([\s\S]+?)\s*<<<REPLACE>>>\s*([\s\S]+?)\s*<<<END_ACTION>>>/g;
+  
+  while ((match = editFileRegex.exec(response)) !== null) {
+    actions.push({
+      type: 'EDIT_FILE',
+      path: match[1].trim(),
+      description: match[2].trim(),
+      find: match[3].trim(),
+      replace: match[4].trim(),
+    });
+  }
+
+  // Parse RUN_COMMAND actions
+  const runCommandRegex = /<<<ACTION:RUN_COMMAND>>>\s*COMMAND:\s*(.+?)\s*DESCRIPTION:\s*(.+?)\s*<<<END_ACTION>>>/g;
+  
+  while ((match = runCommandRegex.exec(response)) !== null) {
+    actions.push({
+      type: 'RUN_COMMAND',
+      command: match[1].trim(),
+      description: match[2].trim(),
+    });
+  }
+
+  return actions;
+}
+
+async function executeAction(action: CodeAction, spinner: ReturnType<typeof p.spinner>): Promise<void> {
+  const cwd = process.cwd();
+
+  switch (action.type) {
+    case 'CREATE_FILE': {
+      const filePath = path.join(cwd, action.path!);
+      await fs.ensureDir(path.dirname(filePath));
+      await fs.writeFile(filePath, action.content!);
+      spinner.message(`Created ${action.path}`);
+      break;
+    }
+
+    case 'EDIT_FILE': {
+      const filePath = path.join(cwd, action.path!);
+      if (await fs.pathExists(filePath)) {
+        let content = await fs.readFile(filePath, 'utf-8');
+        if (action.find && content.includes(action.find)) {
+          content = content.replace(action.find, action.replace || '');
+          await fs.writeFile(filePath, content);
+          spinner.message(`Edited ${action.path}`);
+        }
+      }
+      break;
+    }
+
+    case 'RUN_COMMAND': {
+      spinner.message(`Running: ${action.command}`);
+      const [cmd, ...args] = action.command!.split(' ');
+      await execa(cmd, args, { cwd, stdio: 'pipe' });
+      break;
+    }
+
+    case 'DELETE_FILE': {
+      const filePath = path.join(cwd, action.path!);
+      if (await fs.pathExists(filePath)) {
+        await fs.remove(filePath);
+        spinner.message(`Deleted ${action.path}`);
+      }
+      break;
+    }
+  }
+}
+
+async function checkForWizard(input: string): Promise<string | null> {
+  const lower = input.toLowerCase();
+
+  // Check for feature-building triggers
+  if (lower.includes('add') || lower.includes('create') || lower.includes('build')) {
+    // Check for specific feature types
+    if (lower.includes('auth') || lower.includes('login') || lower.includes('signup')) {
+      return await runAuthWizard(input);
+    }
+    if (lower.includes('payment') || lower.includes('checkout') || lower.includes('stripe')) {
+      return await runPaymentWizard(input);
+    }
+    if (lower.includes('form')) {
+      return await runFormWizard(input);
+    }
+    if (lower.includes('dashboard')) {
+      return await runDashboardWizard(input);
+    }
+    if (lower.includes('chat') || lower.includes('ai')) {
+      return await runAIWizard(input);
+    }
+  }
+
+  return null;
+}
+
+async function runAuthWizard(originalInput: string): Promise<string> {
+  console.log(chalk.cyan('\n🔐 Auth Wizard'));
+  
+  const authType = await p.select({
+    message: 'What type of authentication?',
+    options: [
+      { value: 'magic-link', label: '🔗 Magic link (email)' },
+      { value: 'password', label: '🔑 Password (email + password)' },
+      { value: 'social', label: '🌐 Social login (Google, GitHub)' },
+      { value: 'phone', label: '📱 Phone (SMS code)' },
+    ],
+  });
+
+  if (p.isCancel(authType)) return originalInput;
+
+  const pages = await p.multiselect({
+    message: 'What pages do you need?',
+    options: [
+      { value: 'login', label: 'Login page' },
+      { value: 'signup', label: 'Signup page' },
+      { value: 'forgot', label: 'Forgot password' },
+      { value: 'reset', label: 'Reset password' },
+      { value: 'verify', label: 'Email verification' },
+    ],
+    initialValues: ['login', 'signup'],
+  });
+
+  if (p.isCancel(pages)) return originalInput;
+
+  const redirect = await p.text({
+    message: 'Where should users go after login?',
+    placeholder: '/dashboard',
+    initialValue: '/dashboard',
+  });
+
+  return `Create a complete authentication system with:
+- Auth type: ${authType}
+- Pages: ${(pages as string[]).join(', ')}
+- Redirect after login: ${redirect}
+- Use Supabase Auth
+- Include loading states, error handling, form validation
+- Follow all CodeBakers patterns`;
+}
+
+async function runPaymentWizard(originalInput: string): Promise<string> {
+  console.log(chalk.cyan('\n💳 Payment Wizard'));
+
+  const paymentType = await p.select({
+    message: 'What type of payment flow?',
+    options: [
+      { value: 'one-time', label: '💵 One-time purchase' },
+      { value: 'subscription', label: '🔄 Subscription (recurring)' },
+      { value: 'both', label: '📦 Both' },
+    ],
+  });
+
+  if (p.isCancel(paymentType)) return originalInput;
+
+  const features = await p.multiselect({
+    message: 'What features?',
+    options: [
+      { value: 'checkout', label: 'Checkout page' },
+      { value: 'webhook', label: 'Webhook handler' },
+      { value: 'portal', label: 'Customer portal' },
+      { value: 'invoices', label: 'Invoice history' },
+    ],
+    initialValues: ['checkout', 'webhook'],
+  });
+
+  if (p.isCancel(features)) return originalInput;
+
+  return `Create a complete Stripe payment system with:
+- Payment type: ${paymentType}
+- Features: ${(features as string[]).join(', ')}
+- Use Stripe SDK
+- Include webhook signature verification
+- Handle all error cases
+- Follow all CodeBakers patterns`;
+}
+
+async function runFormWizard(originalInput: string): Promise<string> {
+  console.log(chalk.cyan('\n📝 Form Wizard'));
+
+  const formName = await p.text({
+    message: 'What is this form for?',
+    placeholder: 'Contact form',
+  });
+
+  if (p.isCancel(formName)) return originalInput;
+
+  return `Create a ${formName} form with:
+- React Hook Form for form handling
+- Zod validation schema
+- Loading state during submission
+- Error messages for each field
+- Success toast on completion
+- Proper accessibility (aria labels)
+- Follow all CodeBakers patterns`;
+}
+
+async function runDashboardWizard(originalInput: string): Promise<string> {
+  console.log(chalk.cyan('\n📊 Dashboard Wizard'));
+
+  const components = await p.multiselect({
+    message: 'What components?',
+    options: [
+      { value: 'stats', label: 'Stats cards' },
+      { value: 'chart', label: 'Charts/graphs' },
+      { value: 'table', label: 'Data table' },
+      { value: 'activity', label: 'Activity feed' },
+      { value: 'sidebar', label: 'Sidebar navigation' },
+    ],
+    initialValues: ['stats', 'sidebar'],
+  });
+
+  if (p.isCancel(components)) return originalInput;
+
+  return `Create a dashboard with:
+- Components: ${(components as string[]).join(', ')}
+- Responsive layout
+- Loading skeletons
+- Empty states
+- Error boundaries
+- Follow all CodeBakers patterns`;
+}
+
+async function runAIWizard(originalInput: string): Promise<string> {
+  console.log(chalk.cyan('\n🤖 AI Feature Wizard'));
+
+  const aiType = await p.select({
+    message: 'What AI feature?',
+    options: [
+      { value: 'chat', label: '💬 Chat interface' },
+      { value: 'generate', label: '📝 Content generation' },
+      { value: 'analyze', label: '🔍 Data analysis' },
+    ],
+  });
+
+  if (p.isCancel(aiType)) return originalInput;
+
+  const streaming = await p.confirm({
+    message: 'Use streaming responses?',
+    initialValue: true,
+  });
+
+  return `Create an AI ${aiType} feature with:
+- Streaming: ${streaming ? 'Yes' : 'No'}
+- Use Anthropic Claude API
+- Include conversation history
+- Loading indicators
+- Error handling
+- Stop generation button
+- Follow all CodeBakers patterns`;
+}
+
+async function handleSlashCommand(
+  command: string,
+  context: ProjectContext,
+  config: Config
+): Promise<void> {
+  const [cmd, ...args] = command.slice(1).split(' ');
+
+  switch (cmd.toLowerCase()) {
+    case 'deploy':
+      console.log(chalk.dim('Running deploy...'));
+      // Import and run deploy command
+      break;
+    case 'check':
+      console.log(chalk.dim('Running pattern check...'));
+      await runPatternCheck(false);
+      break;
+    case 'status':
+      console.log(chalk.cyan(`
+Project: ${context.name}
+Framework: ${context.framework}
+UI: ${context.ui}
+Files: ${context.existingFiles.length}
+`));
+      break;
+    case 'undo':
+      console.log(chalk.yellow('Undo not yet implemented'));
+      break;
+    case 'help':
+      showHelp();
+      break;
+    default:
+      console.log(chalk.dim(`Unknown command: ${cmd}`));
+  }
+}
+
+function showHelp(): void {
+  console.log(chalk.cyan(`
+Available commands:
+
+  /deploy      Deploy to production
+  /check       Run pattern check
+  /status      Show project status
+  /undo        Undo last change
+  /help        Show this help
+
+Tips:
+  • Just describe what you want to build
+  • I'll ask clarifying questions if needed
+  • All code follows your CodeBakers patterns
+  • Patterns are auto-checked after every change
+`));
+}
+
+async function autoFixViolations(
+  violations: Array<{ file: string; rule: string; message: string }>,
+  anthropic: Anthropic,
+  systemPrompt: string
+): Promise<void> {
+  // Group violations 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 content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
+    
+    const fixPrompt = `Fix these violations in ${file}:
+
+${fileViolations.map(v => `- ${v.rule}: ${v.message}`).join('\n')}
+
+Current file content:
+\`\`\`
+${content}
+\`\`\`
+
+Output only the fixed file content, no explanation.`;
+
+    const response = await anthropic.messages.create({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 8192,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: fixPrompt }],
+    });
+
+    const fixedContent = response.content[0].type === 'text'
+      ? response.content[0].text
+      : '';
+
+    // Extract code from markdown if present
+    const codeMatch = fixedContent.match(/```(?:tsx?|jsx?)?\n([\s\S]+?)\n```/);
+    const finalContent = codeMatch ? codeMatch[1] : fixedContent;
+
+    await fs.writeFile(path.join(process.cwd(), file), finalContent);
+  }
+}

package/src/commands/connect.ts

@@ -0,0 +1,12 @@
+// src/commands/connect.ts
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { Config } from '../utils/config.js';
+import { setupCommand } from './setup.js';
+
+export async function connectCommand(service?: string): Promise<void> {
+  const config = new Config();
+  
+  // Delegate to setup for now
+  await setupCommand();
+}