@codebakers/cli 1.4.1 → 1.4.2

package/src/commands/scaffold.ts

@@ -1,10 +1,246 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { createInterface } from 'readline';
-import { writeFileSync, mkdirSync, existsSync, readdirSync } from 'fs';
+import { writeFileSync, mkdirSync, existsSync, readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
 import * as templates from '../templates/nextjs-supabase.js';
+import { getApiKey, getApiUrl } from '../config.js';
+
+// Cursor IDE configuration templates
+const CURSORRULES_TEMPLATE = `# CODEBAKERS CURSOR RULES
+# Zero-friction AI assistance - everything is automatic
+
+## ON EVERY MESSAGE - AUTOMATIC WORKFLOW
+
+### PHASE 1: CONTEXT LOAD (automatic)
+1. Read CLAUDE.md → Load router
+2. Read PRD.md → Understand what we're building
+3. Read PROJECT-CONTEXT.md → Understand codebase
+4. Read PROJECT-STATE.md → Check what's in progress
+5. Read DECISIONS.md → Know past decisions
+
+### PHASE 2: PRE-FLIGHT CHECK (before writing code)
+Ask yourself silently:
+- [ ] What existing code does this touch? (check PROJECT-CONTEXT.md)
+- [ ] Is similar code already in the codebase? (copy that pattern)
+- [ ] What's the data model involved?
+- [ ] What are the error cases?
+- [ ] Is someone else working on this? (check PROJECT-STATE.md)
+
+### PHASE 3: EXECUTE
+- State: \`📋 CodeBakers | [Type] | Modules: [list]\`
+- Load required modules from .claude/
+- Follow patterns EXACTLY
+
+### PHASE 4: SELF-REVIEW (before saying "done")
+- [ ] TypeScript compiles? (npx tsc --noEmit)
+- [ ] Imports resolve correctly?
+- [ ] Error handling exists?
+- [ ] Matches existing patterns in codebase?
+- [ ] Tests written?
+- [ ] PROJECT-STATE.md updated?
+
+If ANY check fails, fix it before responding.
+
+## REMEMBER
+- You are a full product team, not just a code assistant
+- The modules contain production-tested patterns — USE THEM
+- When in doubt, check existing code first
+`;
+
+const CURSORIGNORE_TEMPLATE = `# CodeBakers - Files to ignore in Cursor context
+
+# Dependencies
+node_modules/
+.pnpm-store/
+
+# Build outputs
+dist/
+build/
+.next/
+.nuxt/
+out/
+
+# Cache
+.cache/
+.turbo/
+.eslintcache
+*.tsbuildinfo
+
+# Logs
+logs/
+*.log
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Test coverage
+coverage/
+
+# Package locks
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+
+# Generated files
+*.min.js
+*.min.css
+*.map
+`;
+
+function createPrdTemplate(projectName: string): string {
+  const date = new Date().toISOString().split('T')[0];
+  return `# Product Requirements Document
+# Project: ${projectName}
+# Created: ${date}
+
+## Overview
+**One-liner:** [Describe this project in one sentence]
+
+**Problem:** [What problem does this solve?]
+
+**Solution:** [How does this solve it?]
+
+## Target Users
+- **Primary:** [Who is the main user?]
+- **Secondary:** [Other users?]
+
+## Core Features (MVP)
+<!-- List the MINIMUM features needed to launch -->
+
+1. [ ] **Feature 1:** [Description]
+   - Acceptance criteria: [How do we know it's done?]
+
+2. [ ] **Feature 2:** [Description]
+   - Acceptance criteria: [How do we know it's done?]
+
+3. [ ] **Feature 3:** [Description]
+   - Acceptance criteria: [How do we know it's done?]
+
+## Nice-to-Have Features (Post-MVP)
+
+1. [ ] [Feature description]
+2. [ ] [Feature description]
+
+## Technical Requirements
+
+- **Must use:** [Required technologies, APIs, etc.]
+- **Must avoid:** [Things you don't want]
+- **Performance:** [Any speed/scale requirements?]
+- **Security:** [Auth requirements, data sensitivity?]
+
+## Success Metrics
+- [ ] [How will you measure success?]
+- [ ] [What does "done" look like?]
+
+---
+<!-- AI INSTRUCTIONS -->
+<!-- When building features, reference this PRD -->
+<!-- Check off features as they're completed -->
+`;
+}
+
+function createProjectState(projectName: string): string {
+  const date = new Date().toISOString().split('T')[0];
+  return `# PROJECT STATE
+# Last Updated: ${date}
+# Auto-maintained by AI - update when starting/completing tasks
+
+## Project Info
+name: ${projectName}
+phase: setup
+
+## In Progress
+<!-- AI: Add tasks here when you START working on them -->
+
+## Completed
+<!-- AI: Move tasks here when DONE -->
+
+## Next Up
+<!-- AI: Queue of upcoming tasks -->
+`;
+}
+
+function createProjectContext(projectName: string): string {
+  const date = new Date().toISOString().split('T')[0];
+  return `# PROJECT CONTEXT
+# Last Scanned: ${date}
+# AI: Update this when you first analyze the project
+
+## Overview
+name: ${projectName}
+description: [AI will fill after scanning]
+
+## Tech Stack
+framework: Next.js 14
+language: TypeScript
+database: Drizzle ORM + Supabase
+auth: Supabase Auth
+styling: Tailwind CSS
+
+## Project Structure
+\`\`\`
+src/
+├── app/           ← Pages & layouts
+├── components/    ← React components
+├── lib/           ← Utilities & clients
+│   └── supabase/  ← Supabase clients
+├── db/            ← Database schema & queries
+├── services/      ← Business logic
+└── types/         ← TypeScript types
+\`\`\`
+
+## Key Files
+- Entry point: src/app/page.tsx
+- Database schema: src/db/schema.ts
+- API routes: src/app/api/
+
+## Notes
+<!-- AI: Any important context about this specific project -->
+`;
+}
+
+function createDecisionsLog(projectName: string): string {
+  const date = new Date().toISOString().split('T')[0];
+  return `# ARCHITECTURAL DECISIONS
+# Project: ${projectName}
+# AI: Add entries here when making significant technical choices
+
+## How to Use This File
+When you make a decision that affects architecture, add an entry:
+- Date
+- Decision
+- Reason
+- Alternatives considered
+
+---
+
+## ${date}: Project Initialized
+**Decision:** Using CodeBakers pattern system with Next.js + Supabase + Drizzle
+**Reason:** Production-ready stack with type safety and excellent DX
+
+---
+
+<!-- AI: Add new decisions above this line -->
+`;
+}
+
+interface ContentResponse {
+  version: string;
+  router: string;
+  modules: Record<string, string>;
+}
 
 async function prompt(question: string): Promise<string> {
   const rl = createInterface({
@@ -64,7 +300,6 @@ export async function scaffold(): Promise<void> {
   }
 
   const isBeginnerMode = experienceLevel === '1';
-  const showBriefExplanations = experienceLevel === '2';
 
   // Select stack with explanations for beginners
   console.log(chalk.white('\n  Select your stack:\n'));
@@ -200,16 +435,96 @@ export async function scaffold(): Promise<void> {
       }
     }
 
+    spinner.succeed('Project structure created!');
+
+    // Auto-install CodeBakers patterns
+    console.log(chalk.white('\n  Installing CodeBakers patterns...\n'));
+
+    const apiKey = getApiKey();
+    let patternsInstalled = false;
+
+    if (apiKey) {
+      const patternSpinner = ora('  Downloading patterns...').start();
+
+      try {
+        const apiUrl = getApiUrl();
+        const response = await fetch(`${apiUrl}/api/content`, {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+          },
+        });
+
+        if (response.ok) {
+          const content: ContentResponse = await response.json();
+
+          // Write CLAUDE.md (main router)
+          if (content.router) {
+            writeFileSync(join(cwd, 'CLAUDE.md'), content.router);
+          }
+
+          // Write pattern modules to .claude/
+          if (content.modules && Object.keys(content.modules).length > 0) {
+            const modulesDir = join(cwd, '.claude');
+            if (!existsSync(modulesDir)) {
+              mkdirSync(modulesDir, { recursive: true });
+            }
+            for (const [name, data] of Object.entries(content.modules)) {
+              writeFileSync(join(modulesDir, name), data);
+            }
+          }
+
+          // Write project management files
+          writeFileSync(join(cwd, 'PRD.md'), createPrdTemplate(projectName));
+          writeFileSync(join(cwd, 'PROJECT-STATE.md'), createProjectState(projectName));
+          writeFileSync(join(cwd, 'PROJECT-CONTEXT.md'), createProjectContext(projectName));
+          writeFileSync(join(cwd, 'DECISIONS.md'), createDecisionsLog(projectName));
+
+          // Write Cursor IDE files
+          writeFileSync(join(cwd, '.cursorrules'), CURSORRULES_TEMPLATE);
+          writeFileSync(join(cwd, '.cursorignore'), CURSORIGNORE_TEMPLATE);
+
+          // Create .vscode settings
+          const vscodeDir = join(cwd, '.vscode');
+          if (!existsSync(vscodeDir)) {
+            mkdirSync(vscodeDir, { recursive: true });
+          }
+          writeFileSync(join(vscodeDir, 'settings.json'), JSON.stringify({
+            "cursor.chat.defaultContext": ["CLAUDE.md", "PRD.md", "PROJECT-CONTEXT.md"],
+            "cursor.chat.alwaysIncludeRules": true
+          }, null, 2));
+
+          // Update .gitignore
+          const gitignorePath = join(cwd, '.gitignore');
+          if (existsSync(gitignorePath)) {
+            const gitignore = readFileSync(gitignorePath, 'utf-8');
+            if (!gitignore.includes('.cursorrules')) {
+              writeFileSync(gitignorePath, gitignore + '\n# CodeBakers\n.cursorrules\n.claude/\n');
+            }
+          }
+
+          patternSpinner.succeed(`Patterns installed! (v${content.version})`);
+          patternsInstalled = true;
+        } else {
+          patternSpinner.warn('Could not download patterns (will need to run codebakers init later)');
+        }
+      } catch {
+        patternSpinner.warn('Could not download patterns (will need to run codebakers init later)');
+      }
+    } else {
+      console.log(chalk.yellow('  ⚠️  Not logged in - run `codebakers setup` first to get patterns\n'));
+    }
+
     // Success message
     console.log(chalk.green(`
   ╔═══════════════════════════════════════════════════════════╗
   ║                                                           ║
-  ║   ${chalk.bold('✓ Project scaffolded successfully!')}                    ║
+  ║   ${chalk.bold('✓ Project created successfully!')}                       ║
   ║                                                           ║
   ╚═══════════════════════════════════════════════════════════╝
     `));
 
-    console.log(chalk.white('  Project structure:\n'));
+    console.log(chalk.white('  What was created:\n'));
     if (isBeginnerMode) {
       console.log(chalk.gray('    src/'));
       console.log(chalk.gray('    ├── app/           ') + chalk.cyan('← Your pages (what users see)'));
@@ -229,6 +544,13 @@ export async function scaffold(): Promise<void> {
       console.log(chalk.gray('    ├── services/      ') + chalk.cyan('← Business logic'));
       console.log(chalk.gray('    └── types/         ') + chalk.cyan('← TypeScript types'));
     }
+
+    if (patternsInstalled) {
+      console.log('');
+      console.log(chalk.gray('    CLAUDE.md          ') + chalk.cyan('← AI instructions (reads automatically!)'));
+      console.log(chalk.gray('    PRD.md             ') + chalk.cyan('← Your product requirements'));
+      console.log(chalk.gray('    .claude/           ') + chalk.cyan('← 34 production patterns'));
+    }
     console.log('');
 
     console.log(chalk.white('  Next steps:\n'));
@@ -244,14 +566,13 @@ export async function scaffold(): Promise<void> {
       console.log(chalk.gray('       Run: npm run dev'));
       console.log(chalk.gray('       Open: http://localhost:3000 in your browser'));
       console.log('');
-      console.log(chalk.cyan('    4. ') + chalk.white('Add AI superpowers:'));
-      console.log(chalk.gray('       Run: codebakers init'));
-      console.log(chalk.gray('       Now AI will follow professional coding patterns!\n'));
+      console.log(chalk.cyan('    4. ') + chalk.white('Start building!'));
+      console.log(chalk.gray('       Tell your AI: "Build me a [feature]"'));
+      console.log(chalk.gray('       The AI already has all the patterns loaded!\n'));
     } else {
       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.cyan('    3. ') + chalk.gray('Tell your AI what to build - patterns are already loaded!\n'));
 
       console.log(chalk.white('  Supabase setup:\n'));
       console.log(chalk.gray('    1. Create a project at https://supabase.com'));

package/src/commands/serve.ts

@@ -13,9 +13,12 @@ export async function serve(): Promise<void> {
   console.error(chalk.green('  Starting MCP server on stdio...'));
   console.error(chalk.gray('  This server provides pattern tools to Claude Code.\n'));
   console.error(chalk.gray('  Available tools:'));
-  console.error(chalk.gray('    - get_pattern: Fetch a single pattern'));
-  console.error(chalk.gray('    - list_patterns: List all available patterns'));
-  console.error(chalk.gray('    - get_patterns: Fetch multiple patterns\n'));
+  console.error(chalk.gray('    - scaffold_project: Create a new project from AI chat'));
+  console.error(chalk.gray('    - init_project: Add patterns to existing project'));
+  console.error(chalk.gray('    - set_experience_level: Set beginner/intermediate/advanced mode'));
+  console.error(chalk.gray('    - get_experience_level: Check current experience mode'));
+  console.error(chalk.gray('    - optimize_and_build: AI-powered prompt optimization'));
+  console.error(chalk.gray('    - get_pattern, list_patterns, search_patterns\n'));
 
   // Dynamically import and run the MCP server
   const { runServer } = await import('../mcp/server.js');

package/src/commands/setup.ts

@@ -113,10 +113,13 @@ function showFinalInstructions(): void {
   console.log(chalk.white.bold('\n  🎉 Setup Complete!\n'));
   console.log(chalk.blue('  ══════════════════════════════════════════════════════════\n'));
 
-  console.log(chalk.white('  CodeBakers is now ready. Try this prompt:\n'));
-  console.log(chalk.cyan('    "Build a login form with email validation"\n'));
+  console.log(chalk.white.bold('  👉 NEXT: Close this terminal and open your AI:\n'));
+  console.log(chalk.cyan('     • Claude Code') + chalk.gray(' - Open any project folder'));
+  console.log(chalk.cyan('     • Cursor') + chalk.gray(' - Open Composer (Cmd+I / Ctrl+I)\n'));
 
-  console.log(chalk.gray('  Claude will now use CodeBakers patterns automatically.\n'));
+  console.log(chalk.white('  Then just describe what you want to build:\n'));
+  console.log(chalk.green('    "Build me a todo app with user authentication"\n'));
 
+  console.log(chalk.gray('  The AI will use CodeBakers patterns automatically.'));
   console.log(chalk.gray('  Need help? https://codebakers.ai/docs\n'));
 }

package/src/config.ts

@@ -1,8 +1,11 @@
 import Conf from 'conf';
 
+export type ExperienceLevel = 'beginner' | 'intermediate' | 'advanced';
+
 interface ConfigSchema {
   apiKey: string | null;
   apiUrl: string;
+  experienceLevel: ExperienceLevel;
 }
 
 const config = new Conf<ConfigSchema>({
@@ -10,6 +13,7 @@ const config = new Conf<ConfigSchema>({
   defaults: {
     apiKey: null,
     apiUrl: 'https://codebakers.ai',
+    experienceLevel: 'intermediate',
   },
 });
 
@@ -32,3 +36,11 @@ export function getApiUrl(): string {
 export function setApiUrl(url: string): void {
   config.set('apiUrl', url);
 }
+
+export function getExperienceLevel(): ExperienceLevel {
+  return config.get('experienceLevel');
+}
+
+export function setExperienceLevel(level: ExperienceLevel): void {
+  config.set('experienceLevel', level);
+}