codebakers 2.0.1 → 2.0.3

package/src/commands/prd.ts

@@ -0,0 +1,419 @@
+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 { Config } from '../utils/config.js';
+
+interface PRDSection {
+  title: string;
+  content: string;
+}
+
+interface ParsedPRD {
+  name: string;
+  description: string;
+  features: string[];
+  pages: string[];
+  database: string[];
+  integrations: string[];
+  design: {
+    profile?: string;
+    brandColor?: string;
+  };
+}
+
+export async function prdCommand(filePath?: string): Promise<void> {
+  const config = new Config();
+
+  if (!config.isConfigured()) {
+    p.log.error('Please run `codebakers setup` first.');
+    return;
+  }
+
+  p.intro(chalk.bgCyan.black(' Build from PRD '));
+
+  // Get PRD file
+  let prdPath = filePath;
+  if (!prdPath) {
+    const file = await p.text({
+      message: 'Path to PRD file:',
+      placeholder: './PRD.md or paste URL',
+      validate: (v) => !v ? 'File path required' : undefined,
+    });
+    if (p.isCancel(file)) return;
+    prdPath = file as string;
+  }
+
+  // Read PRD
+  const spinner = p.spinner();
+  spinner.start('Reading PRD...');
+
+  let prdContent: string;
+  try {
+    if (prdPath.startsWith('http')) {
+      const response = await fetch(prdPath);
+      prdContent = await response.text();
+    } else {
+      prdContent = await fs.readFile(prdPath, 'utf-8');
+    }
+  } catch (error) {
+    spinner.stop('Error');
+    p.log.error(`Could not read PRD: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    return;
+  }
+
+  spinner.stop('PRD loaded');
+
+  // Parse PRD with AI
+  spinner.start('Analyzing PRD...');
+  
+  const anthropicCreds = config.getCredentials('anthropic');
+  if (!anthropicCreds?.apiKey) {
+    spinner.stop('Error');
+    p.log.error('Anthropic API key not configured.');
+    return;
+  }
+
+  const anthropic = new Anthropic({ apiKey: anthropicCreds.apiKey });
+
+  const parsed = await parsePRD(anthropic, prdContent);
+  spinner.stop('PRD analyzed');
+
+  // Show what was extracted
+  console.log(chalk.bold('\n📋 Extracted from PRD:\n'));
+  console.log(`  ${chalk.cyan('Name:')} ${parsed.name}`);
+  console.log(`  ${chalk.cyan('Description:')} ${parsed.description}`);
+  console.log(`  ${chalk.cyan('Features:')} ${parsed.features.length} features`);
+  console.log(`  ${chalk.cyan('Pages:')} ${parsed.pages.join(', ') || 'Auto-detect'}`);
+  console.log(`  ${chalk.cyan('Database:')} ${parsed.database.length} tables`);
+  console.log(`  ${chalk.cyan('Integrations:')} ${parsed.integrations.join(', ') || 'None'}`);
+  console.log('');
+
+  // Show features
+  if (parsed.features.length > 0) {
+    console.log(chalk.bold('Features to build:'));
+    parsed.features.slice(0, 10).forEach((f, i) => {
+      console.log(chalk.dim(`  ${i + 1}. ${f}`));
+    });
+    if (parsed.features.length > 10) {
+      console.log(chalk.dim(`  ... and ${parsed.features.length - 10} more`));
+    }
+    console.log('');
+  }
+
+  // Confirm
+  const proceed = await p.confirm({
+    message: 'Build this project?',
+    initialValue: true,
+  });
+
+  if (!proceed || p.isCancel(proceed)) {
+    p.cancel('Cancelled');
+    return;
+  }
+
+  // Build options
+  const options = await p.group({
+    createInfra: () => p.confirm({
+      message: 'Create GitHub + Vercel + Supabase?',
+      initialValue: true,
+    }),
+    designProfile: () => p.select({
+      message: 'Design profile:',
+      options: [
+        { value: 'minimal', label: 'Minimal (Linear, Notion)' },
+        { value: 'bold', label: 'Bold (Stripe, Ramp)' },
+        { value: 'editorial', label: 'Editorial (Medium, Substack)' },
+        { value: 'playful', label: 'Playful (Figma, Slack)' },
+        { value: 'premium', label: 'Premium (Apple, Porsche)' },
+        { value: 'dashboard', label: 'Dashboard (Datadog, Linear)' },
+      ],
+      initialValue: parsed.design.profile || 'minimal',
+    }),
+  });
+
+  if (p.isCancel(options)) return;
+
+  // Build the project
+  await buildFromPRD(parsed, options, anthropic, config);
+}
+
+async function parsePRD(anthropic: Anthropic, content: string): Promise<ParsedPRD> {
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 4096,
+    messages: [{
+      role: 'user',
+      content: `Analyze this PRD and extract structured information. Return JSON only, no explanation.
+
+PRD:
+${content}
+
+Return this exact JSON structure:
+{
+  "name": "project name (lowercase, hyphenated)",
+  "description": "one sentence description",
+  "features": ["feature 1", "feature 2", ...],
+  "pages": ["page1", "page2", ...],
+  "database": ["table1", "table2", ...],
+  "integrations": ["stripe", "supabase", ...],
+  "design": {
+    "profile": "minimal|bold|editorial|playful|premium|dashboard or null",
+    "brandColor": "#hexcolor or null"
+  }
+}
+
+Extract ALL features mentioned. Include auth, payments, dashboards, etc.
+For pages, list actual pages/routes needed.
+For database, list tables/entities needed.
+For integrations, list third-party services mentioned.`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+  
+  // Extract JSON from response
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error('Could not parse PRD');
+  }
+
+  return JSON.parse(jsonMatch[0]);
+}
+
+async function buildFromPRD(
+  prd: ParsedPRD,
+  options: { createInfra: boolean; designProfile: string },
+  anthropic: Anthropic,
+  config: Config
+): Promise<void> {
+  const spinner = p.spinner();
+  const projectPath = path.join(process.cwd(), prd.name);
+
+  // Step 1: Create project structure
+  spinner.start('Creating project structure...');
+  await fs.ensureDir(projectPath);
+  await fs.ensureDir(path.join(projectPath, '.codebakers'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'app'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'components'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'lib'));
+  spinner.stop('Project structure created');
+
+  // Step 2: Save PRD to project
+  spinner.start('Saving PRD...');
+  await fs.writeFile(path.join(projectPath, 'PRD.md'), await fs.readFile(process.cwd(), 'utf-8').catch(() => JSON.stringify(prd, null, 2)));
+  await fs.writeJson(path.join(projectPath, '.codebakers', 'prd.json'), prd, { spaces: 2 });
+  await fs.writeJson(path.join(projectPath, '.codebakers', 'design.json'), {
+    profile: options.designProfile,
+    colors: prd.design.brandColor ? { brand: prd.design.brandColor } : undefined,
+  }, { spaces: 2 });
+  spinner.stop('PRD saved');
+
+  // Step 3: Generate build plan
+  spinner.start('Generating build plan...');
+  const buildPlan = await generateBuildPlan(anthropic, prd, options.designProfile);
+  await fs.writeJson(path.join(projectPath, '.codebakers', 'build-plan.json'), buildPlan, { spaces: 2 });
+  spinner.stop('Build plan generated');
+
+  // Show build plan
+  console.log(chalk.bold('\n🏗️  Build Plan:\n'));
+  buildPlan.phases.forEach((phase: any, i: number) => {
+    console.log(chalk.cyan(`Phase ${i + 1}: ${phase.name}`));
+    phase.tasks.forEach((task: string) => {
+      console.log(chalk.dim(`  • ${task}`));
+    });
+  });
+  console.log('');
+
+  // Step 4: Execute build plan
+  const startBuild = await p.confirm({
+    message: 'Start building?',
+    initialValue: true,
+  });
+
+  if (!startBuild || p.isCancel(startBuild)) {
+    p.log.info(`Build plan saved to ${prd.name}/.codebakers/build-plan.json`);
+    p.log.info(`Run \`cd ${prd.name} && codebakers code\` to continue building.`);
+    return;
+  }
+
+  // Execute each phase
+  for (let i = 0; i < buildPlan.phases.length; i++) {
+    const phase = buildPlan.phases[i];
+    console.log(chalk.bold(`\n📦 Phase ${i + 1}: ${phase.name}\n`));
+
+    for (const task of phase.tasks) {
+      spinner.start(task);
+      
+      try {
+        await executeTask(anthropic, projectPath, task, prd, options.designProfile);
+        spinner.stop(`✓ ${task}`);
+      } catch (error) {
+        spinner.stop(`✗ ${task}`);
+        p.log.error(error instanceof Error ? error.message : 'Task failed');
+        
+        const continueBuilding = await p.confirm({
+          message: 'Continue with next task?',
+          initialValue: true,
+        });
+        
+        if (!continueBuilding || p.isCancel(continueBuilding)) {
+          p.log.info('Build paused. Run `codebakers code` to continue.');
+          return;
+        }
+      }
+    }
+  }
+
+  // Step 5: Infrastructure (if selected)
+  if (options.createInfra) {
+    console.log(chalk.bold('\n🚀 Setting up infrastructure...\n'));
+    
+    spinner.start('Creating GitHub repository...');
+    // Would call GitHub service
+    spinner.stop('GitHub repository created');
+
+    spinner.start('Creating Supabase project...');
+    // Would call Supabase service  
+    spinner.stop('Supabase project created');
+
+    spinner.start('Creating Vercel project...');
+    // Would call Vercel service
+    spinner.stop('Vercel project created');
+
+    spinner.start('Deploying...');
+    // Would deploy
+    spinner.stop('Deployed!');
+  }
+
+  // Done!
+  p.outro(chalk.green(`
+✓ Project built from PRD!
+
+${chalk.bold('Your project:')}
+  ${chalk.cyan(`cd ${prd.name}`)}
+  ${chalk.cyan('npm run dev')}
+
+${chalk.bold('Continue building:')}
+  ${chalk.cyan('codebakers code')} — AI agent
+  ${chalk.cyan('codebakers check')} — Verify patterns
+  ${chalk.cyan('codebakers deploy')} — Deploy changes
+`));
+}
+
+async function generateBuildPlan(
+  anthropic: Anthropic,
+  prd: ParsedPRD,
+  designProfile: string
+): Promise<{ phases: Array<{ name: string; tasks: string[] }> }> {
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 4096,
+    messages: [{
+      role: 'user',
+      content: `Create a build plan for this project. Return JSON only.
+
+Project: ${prd.name}
+Description: ${prd.description}
+Features: ${prd.features.join(', ')}
+Pages: ${prd.pages.join(', ')}
+Database tables: ${prd.database.join(', ')}
+Integrations: ${prd.integrations.join(', ')}
+Design: ${designProfile}
+
+Return this structure:
+{
+  "phases": [
+    {
+      "name": "Phase name",
+      "tasks": ["task 1", "task 2", ...]
+    }
+  ]
+}
+
+Phases should be:
+1. Setup (package.json, config, base files)
+2. Database (schema, migrations, types)
+3. Auth (if needed)
+4. Core Features (main functionality)
+5. UI/Pages (frontend)
+6. Integrations (third-party services)
+7. Polish (loading states, error handling, empty states)
+
+Keep tasks specific and actionable.`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error('Could not generate build plan');
+  }
+
+  return JSON.parse(jsonMatch[0]);
+}
+
+async function executeTask(
+  anthropic: Anthropic,
+  projectPath: string,
+  task: string,
+  prd: ParsedPRD,
+  designProfile: string
+): Promise<void> {
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 8192,
+    messages: [{
+      role: 'user',
+      content: `Execute this task for the project.
+
+Project: ${prd.name}
+Task: ${task}
+Design Profile: ${designProfile}
+
+Context:
+- Features: ${prd.features.join(', ')}
+- Database: ${prd.database.join(', ')}
+
+Output files in this format:
+
+<<<FILE: path/to/file.ts>>>
+file content here
+<<<END_FILE>>>
+
+<<<FILE: another/file.tsx>>>
+file content here  
+<<<END_FILE>>>
+
+Follow these rules:
+- Use TypeScript
+- Use Next.js App Router
+- Use Tailwind CSS
+- Use shadcn/ui components
+- Every button needs onClick handler
+- Every form needs Zod validation
+- Every async operation needs loading/error states
+- Every list needs empty state
+- No generic gradient heroes
+- No icon spam
+- Generous spacing (py-16 or larger for sections)
+
+Generate ALL files needed for this task.`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+
+  // Parse and write files
+  const fileRegex = /<<<FILE:\s*(.+?)>>>([\s\S]*?)<<<END_FILE>>>/g;
+  let match;
+
+  while ((match = fileRegex.exec(text)) !== null) {
+    const filePath = path.join(projectPath, match[1].trim());
+    const content = match[2].trim();
+
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
+  }
+}

package/src/index.ts

@@ -20,6 +20,8 @@ import { securityCommand } from './commands/security.js';
 import { generateCommand } from './commands/generate.js';
 import { fixCommand } from './commands/fix.js';
 import { designCommand } from './commands/design.js';
+import { prdCommand } from './commands/prd.js';
+import { advisorsCommand } from './commands/advisors.js';
 
 const VERSION = '1.0.0';
 
@@ -73,10 +75,14 @@ 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: '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: 'advisors', label: '🌟 Dream Team Advisors', hint: 'consult with experts' },
       { value: 'open', label: '📂 Open existing project' },
       { value: 'status', label: '📊 View all projects' },
       { value: 'separator1', label: '─────────────────────────' },
@@ -131,6 +137,12 @@ async function showMainMenu(): Promise<void> {
     case 'new':
       await initCommand();
       break;
+    case 'prd':
+      await prdCommand();
+      break;
+    case 'advisors':
+      await advisorsCommand();
+      break;
     case 'settings':
       await setupCommand();
       break;
@@ -264,6 +276,17 @@ program
   .description('Manage design system (profile, palette, check)')
   .action(designCommand);
 
+program
+  .command('prd [file]')
+  .description('Build entire project from a PRD document')
+  .action(prdCommand);
+
+program
+  .command('advisors')
+  .alias('dream-team')
+  .description('Consult with the CodeBakers Dream Team advisory board')
+  .action(advisorsCommand);
+
 // 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