@codebakers/cli 1.2.1 → 1.3.0

package/src/commands/scaffold.ts

@@ -0,0 +1,196 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { createInterface } from 'readline';
+import { writeFileSync, mkdirSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import * as templates from '../templates/nextjs-supabase.js';
+
+async function prompt(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function confirm(question: string): Promise<boolean> {
+  const answer = await prompt(`${question} (Y/n): `);
+  return answer.toLowerCase() !== 'n';
+}
+
+/**
+ * Scaffold a new project with full structure
+ */
+export async function scaffold(): Promise<void> {
+  console.log(chalk.blue(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║                                                           ║
+  ║   ${chalk.bold('CodeBakers Project Scaffolding')}                        ║
+  ║                                                           ║
+  ║   Create a production-ready project in seconds            ║
+  ║                                                           ║
+  ╚═══════════════════════════════════════════════════════════╝
+  `));
+
+  const cwd = process.cwd();
+  const files = readdirSync(cwd);
+  const hasFiles = files.filter(f => !f.startsWith('.')).length > 0;
+
+  if (hasFiles) {
+    console.log(chalk.yellow('  ⚠️  This directory is not empty.\n'));
+    const proceed = await confirm('  Continue anyway? (Existing files may be overwritten)');
+    if (!proceed) {
+      console.log(chalk.gray('\n  Run this command in an empty directory.\n'));
+      return;
+    }
+  }
+
+  // Select stack
+  console.log(chalk.white('\n  Select your stack:\n'));
+  console.log(chalk.gray('    1. ') + chalk.cyan('Next.js + Supabase + Drizzle') + chalk.gray(' (Recommended)'));
+  console.log(chalk.gray('    2. ') + chalk.cyan('Next.js + Prisma') + chalk.gray(' (Coming soon)'));
+  console.log(chalk.gray('    3. ') + chalk.cyan('Express API') + chalk.gray(' (Coming soon)\n'));
+
+  let stackChoice = '';
+  while (!['1', '2', '3'].includes(stackChoice)) {
+    stackChoice = await prompt('  Enter 1, 2, or 3: ');
+  }
+
+  if (stackChoice !== '1') {
+    console.log(chalk.yellow('\n  That stack is coming soon! Using Next.js + Supabase + Drizzle.\n'));
+    stackChoice = '1';
+  }
+
+  // Get project name
+  const defaultName = cwd.split(/[\\/]/).pop() || 'my-project';
+  const projectName = await prompt(`  Project name (${defaultName}): `) || defaultName;
+
+  console.log(chalk.green(`\n  Creating ${projectName} with Next.js + Supabase + Drizzle...\n`));
+
+  // Create project structure
+  const spinner = ora('  Creating project structure...').start();
+
+  try {
+    // Create directories
+    const dirs = [
+      'src/app',
+      'src/components',
+      'src/lib/supabase',
+      'src/db',
+      'src/db/migrations',
+      'src/services',
+      'src/types',
+      'public',
+    ];
+
+    for (const dir of dirs) {
+      const dirPath = join(cwd, dir);
+      if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+      }
+    }
+
+    spinner.text = '  Writing configuration files...';
+
+    // Write package.json
+    const packageJson = { ...templates.PACKAGE_JSON, name: projectName };
+    writeFileSync(join(cwd, 'package.json'), JSON.stringify(packageJson, null, 2));
+
+    // Write .env.example
+    writeFileSync(join(cwd, '.env.example'), templates.ENV_EXAMPLE);
+    writeFileSync(join(cwd, '.env.local'), templates.ENV_EXAMPLE);
+
+    // Write config files
+    writeFileSync(join(cwd, 'drizzle.config.ts'), templates.DRIZZLE_CONFIG);
+    writeFileSync(join(cwd, 'tailwind.config.ts'), templates.TAILWIND_CONFIG);
+    writeFileSync(join(cwd, 'postcss.config.mjs'), templates.POSTCSS_CONFIG);
+    writeFileSync(join(cwd, 'tsconfig.json'), JSON.stringify(templates.TSCONFIG, null, 2));
+    writeFileSync(join(cwd, 'next.config.ts'), templates.NEXT_CONFIG);
+    writeFileSync(join(cwd, '.gitignore'), templates.GITIGNORE);
+
+    spinner.text = '  Writing source files...';
+
+    // Write Supabase files
+    writeFileSync(join(cwd, 'src/lib/supabase/server.ts'), templates.SUPABASE_SERVER);
+    writeFileSync(join(cwd, 'src/lib/supabase/client.ts'), templates.SUPABASE_CLIENT);
+    writeFileSync(join(cwd, 'src/lib/supabase/middleware.ts'), templates.SUPABASE_MIDDLEWARE);
+
+    // Write middleware
+    writeFileSync(join(cwd, 'middleware.ts'), templates.MIDDLEWARE);
+
+    // Write database files
+    writeFileSync(join(cwd, 'src/db/schema.ts'), templates.DB_SCHEMA);
+    writeFileSync(join(cwd, 'src/db/index.ts'), templates.DB_INDEX);
+
+    // Write app files
+    writeFileSync(join(cwd, 'src/app/globals.css'), templates.GLOBALS_CSS);
+    writeFileSync(join(cwd, 'src/app/layout.tsx'), templates.LAYOUT_TSX);
+    writeFileSync(join(cwd, 'src/app/page.tsx'), templates.PAGE_TSX);
+
+    // Write utils
+    writeFileSync(join(cwd, 'src/lib/utils.ts'), templates.UTILS_CN);
+
+    spinner.succeed('Project structure created!');
+
+    // Ask about installing dependencies
+    console.log('');
+    const installDeps = await confirm('  Install dependencies with npm?');
+
+    if (installDeps) {
+      const installSpinner = ora('  Installing dependencies (this may take a minute)...').start();
+      try {
+        execSync('npm install', { cwd, stdio: 'pipe' });
+        installSpinner.succeed('Dependencies installed!');
+      } catch (error) {
+        installSpinner.warn('Could not install dependencies automatically');
+        console.log(chalk.gray('  Run `npm install` manually.\n'));
+      }
+    }
+
+    // Success message
+    console.log(chalk.green(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║                                                           ║
+  ║   ${chalk.bold('✓ Project scaffolded successfully!')}                    ║
+  ║                                                           ║
+  ╚═══════════════════════════════════════════════════════════╝
+    `));
+
+    console.log(chalk.white('  Project structure:\n'));
+    console.log(chalk.gray('    src/'));
+    console.log(chalk.gray('    ├── app/           ') + chalk.cyan('← Pages & layouts'));
+    console.log(chalk.gray('    ├── components/    ') + chalk.cyan('← React components'));
+    console.log(chalk.gray('    ├── lib/           ') + chalk.cyan('← Utilities & clients'));
+    console.log(chalk.gray('    │   └── supabase/  ') + chalk.cyan('← Supabase clients (ready!)'));
+    console.log(chalk.gray('    ├── db/            ') + chalk.cyan('← Database schema & queries'));
+    console.log(chalk.gray('    ├── services/      ') + chalk.cyan('← Business logic'));
+    console.log(chalk.gray('    └── types/         ') + chalk.cyan('← TypeScript types'));
+    console.log('');
+
+    console.log(chalk.white('  Next steps:\n'));
+    console.log(chalk.cyan('    1. ') + chalk.gray('Update .env.local with your Supabase credentials'));
+    console.log(chalk.cyan('    2. ') + chalk.gray('Run `npm run dev` to start development'));
+    console.log(chalk.cyan('    3. ') + chalk.gray('Run `codebakers init` to add CodeBakers patterns'));
+    console.log(chalk.cyan('    4. ') + chalk.gray('Start building with AI assistance!\n'));
+
+    console.log(chalk.white('  Supabase setup:\n'));
+    console.log(chalk.gray('    1. Create a project at https://supabase.com'));
+    console.log(chalk.gray('    2. Go to Settings → API'));
+    console.log(chalk.gray('    3. Copy URL and anon key to .env.local'));
+    console.log(chalk.gray('    4. Go to Settings → Database → Connection string'));
+    console.log(chalk.gray('    5. Copy DATABASE_URL to .env.local\n'));
+
+  } catch (error) {
+    spinner.fail('Project scaffolding failed');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.log(chalk.red(`\n  Error: ${message}\n`));
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -11,6 +11,7 @@ import { init } from './commands/init.js';
 import { serve } from './commands/serve.js';
 import { mcpConfig, mcpUninstall } from './commands/mcp-config.js';
 import { setup } from './commands/setup.js';
+import { scaffold } from './commands/scaffold.js';
 
 const program = new Command();
 
@@ -30,6 +31,12 @@ program
   .description('Interactive project setup wizard')
   .action(init);
 
+program
+  .command('scaffold')
+  .alias('new')
+  .description('Create a new project with full stack scaffolding (Next.js + Supabase + Drizzle)')
+  .action(scaffold);
+
 program
   .command('login')
   .description('Login with your API key')

package/src/mcp/server.ts

@@ -343,6 +343,40 @@ class CodeBakersServer {
             required: ['patterns'],
           },
         },
+        {
+          name: 'search_patterns',
+          description:
+            'Search CodeBakers patterns by keyword or topic. Returns relevant code snippets without reading entire files. Use this when you need specific guidance like "supabase auth setup", "optimistic updates", "soft delete", "form validation".',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              query: {
+                type: 'string',
+                description: 'Search query (e.g., "supabase auth", "stripe checkout", "zod validation", "loading states")',
+              },
+            },
+            required: ['query'],
+          },
+        },
+        {
+          name: 'get_pattern_section',
+          description:
+            'Get a specific section from a pattern file instead of the whole file. Much faster than get_pattern for targeted lookups.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              pattern: {
+                type: 'string',
+                description: 'Pattern name (e.g., "02-auth", "03-api")',
+              },
+              section: {
+                type: 'string',
+                description: 'Section name or keyword to find within the pattern (e.g., "OAuth", "rate limiting", "error handling")',
+              },
+            },
+            required: ['pattern', 'section'],
+          },
+        },
       ],
     }));
 
@@ -370,6 +404,12 @@ class CodeBakersServer {
         case 'get_patterns':
           return this.handleGetPatterns(args as { patterns: string[] });
 
+        case 'search_patterns':
+          return this.handleSearchPatterns(args as { query: string });
+
+        case 'get_pattern_section':
+          return this.handleGetPatternSection(args as { pattern: string; section: string });
+
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
       }
@@ -592,6 +632,210 @@ Show the user what their simple request was expanded into, then proceed with the
     return response.json();
   }
 
+  private async handleSearchPatterns(args: { query: string }) {
+    const { query } = args;
+
+    // Call API endpoint for semantic search
+    const response = await fetch(`${this.apiUrl}/api/patterns/search`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({ query }),
+    });
+
+    if (!response.ok) {
+      // Fallback: If search endpoint doesn't exist, do client-side search
+      return this.fallbackSearch(query);
+    }
+
+    const data = await response.json();
+
+    const results = data.results
+      .map((r: { pattern: string; section: string; content: string; relevance: number }) =>
+        `### ${r.pattern} - ${r.section}\n\n\`\`\`typescript\n${r.content}\n\`\`\`\n\nRelevance: ${Math.round(r.relevance * 100)}%`
+      )
+      .join('\n\n---\n\n');
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `# Search Results for "${query}"\n\n${results || 'No results found. Try a different query.'}`,
+        },
+      ],
+    };
+  }
+
+  private async fallbackSearch(query: string) {
+    // Keyword-based fallback if API search not available
+    const keywordPatternMap: Record<string, string[]> = {
+      'auth': ['02-auth'],
+      'login': ['02-auth'],
+      'oauth': ['02-auth'],
+      'supabase': ['02-auth', '01-database'],
+      'database': ['01-database'],
+      'drizzle': ['01-database'],
+      'schema': ['01-database'],
+      'api': ['03-api'],
+      'route': ['03-api'],
+      'validation': ['03-api', '04-frontend'],
+      'zod': ['03-api', '04-frontend'],
+      'frontend': ['04-frontend'],
+      'form': ['04-frontend'],
+      'react': ['04-frontend'],
+      'component': ['04-frontend'],
+      'stripe': ['05-payments'],
+      'payment': ['05-payments'],
+      'checkout': ['05-payments'],
+      'subscription': ['05-payments'],
+      'email': ['06-integrations'],
+      'webhook': ['06-integrations'],
+      'cache': ['07-performance'],
+      'test': ['08-testing'],
+      'playwright': ['08-testing'],
+      'design': ['09-design'],
+      'ui': ['09-design'],
+      'accessibility': ['09-design'],
+      'websocket': ['11-realtime'],
+      'realtime': ['11-realtime'],
+      'notification': ['11-realtime'],
+      'saas': ['12-saas'],
+      'tenant': ['12-saas'],
+      'mobile': ['13-mobile'],
+      'expo': ['13-mobile'],
+      'ai': ['14-ai'],
+      'openai': ['14-ai'],
+      'embedding': ['14-ai'],
+      'analytics': ['26-analytics'],
+      'search': ['27-search'],
+      'animation': ['30-motion'],
+      'framer': ['30-motion'],
+    };
+
+    const lowerQuery = query.toLowerCase();
+    const matchedPatterns = new Set<string>();
+
+    for (const [keyword, patterns] of Object.entries(keywordPatternMap)) {
+      if (lowerQuery.includes(keyword)) {
+        patterns.forEach(p => matchedPatterns.add(p));
+      }
+    }
+
+    if (matchedPatterns.size === 0) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `# No patterns found for "${query}"\n\nTry:\n- "auth" for authentication patterns\n- "api" for API route patterns\n- "form" for frontend form patterns\n- "stripe" for payment patterns\n\nOr use \`list_patterns\` to see all available patterns.`,
+          },
+        ],
+      };
+    }
+
+    const patterns = Array.from(matchedPatterns).slice(0, 3);
+    const result = await this.fetchPatterns(patterns);
+
+    const content = Object.entries(result.patterns || {})
+      .map(([name, text]) => `## ${name}\n\n${text}`)
+      .join('\n\n---\n\n');
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `# Patterns matching "${query}"\n\nFound in: ${patterns.join(', ')}\n\n${content}`,
+        },
+      ],
+    };
+  }
+
+  private async handleGetPatternSection(args: { pattern: string; section: string }) {
+    const { pattern, section } = args;
+
+    // Fetch the full pattern first
+    const result = await this.fetchPatterns([pattern]);
+
+    if (!result.patterns || !result.patterns[pattern]) {
+      throw new McpError(
+        ErrorCode.InvalidRequest,
+        `Pattern "${pattern}" not found. Use list_patterns to see available patterns.`
+      );
+    }
+
+    const fullContent = result.patterns[pattern];
+
+    // Find the section (case-insensitive search for headers or content)
+    const sectionLower = section.toLowerCase();
+    const lines = fullContent.split('\n');
+    const sections: string[] = [];
+    let currentSection = '';
+    let currentContent: string[] = [];
+    let capturing = false;
+    let relevanceScore = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Check if this is a header
+      if (line.match(/^#{1,3}\s/)) {
+        // Save previous section if we were capturing
+        if (capturing && currentContent.length > 0) {
+          sections.push(`### ${currentSection}\n\n${currentContent.join('\n')}`);
+        }
+
+        currentSection = line.replace(/^#+\s*/, '');
+        currentContent = [];
+
+        // Check if this section matches our query
+        if (currentSection.toLowerCase().includes(sectionLower)) {
+          capturing = true;
+          relevanceScore++;
+        } else {
+          capturing = false;
+        }
+      } else if (capturing) {
+        currentContent.push(line);
+      }
+
+      // Also check content for keyword matches
+      if (!capturing && line.toLowerCase().includes(sectionLower)) {
+        // Found keyword in content, capture surrounding context
+        const start = Math.max(0, i - 5);
+        const end = Math.min(lines.length, i + 20);
+        const context = lines.slice(start, end).join('\n');
+        sections.push(`### Found at line ${i + 1}\n\n${context}`);
+        relevanceScore++;
+      }
+    }
+
+    // Capture last section if we were still capturing
+    if (capturing && currentContent.length > 0) {
+      sections.push(`### ${currentSection}\n\n${currentContent.join('\n')}`);
+    }
+
+    if (sections.length === 0) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `# Section "${section}" not found in ${pattern}\n\nThe pattern exists but doesn't contain a section matching "${section}".\n\nTry:\n- A broader search term\n- \`get_pattern ${pattern}\` to see the full content\n- \`search_patterns ${section}\` to search across all patterns`,
+          },
+        ],
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `# ${pattern} - "${section}"\n\n${sections.slice(0, 5).join('\n\n---\n\n')}`,
+        },
+      ],
+    };
+  }
+
   async run(): Promise<void> {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);