@codebakers/cli 1.4.0 → 1.4.2

package/dist/mcp/server.js

@@ -41,6 +41,8 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const config_js_1 = require("../config.js");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const templates = __importStar(require("../templates/nextjs-supabase.js"));
 // Pattern cache to avoid repeated API calls
 const patternCache = new Map();
 const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
@@ -357,6 +359,60 @@ class CodeBakersServer {
                         required: ['pattern', 'section'],
                     },
                 },
+                {
+                    name: 'scaffold_project',
+                    description: 'Create a new project from scratch with Next.js + Supabase + Drizzle. Use this when user wants to build something new and no project exists yet. Creates all files, installs dependencies, and sets up CodeBakers patterns automatically.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectName: {
+                                type: 'string',
+                                description: 'Name of the project (lowercase, no spaces)',
+                            },
+                            description: {
+                                type: 'string',
+                                description: 'Brief description of what the project is for (used in PRD.md)',
+                            },
+                        },
+                        required: ['projectName'],
+                    },
+                },
+                {
+                    name: 'init_project',
+                    description: 'Add CodeBakers patterns to an existing project. Use this when user has an existing codebase and wants to add AI patterns to it.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectName: {
+                                type: 'string',
+                                description: 'Name of the project (optional, will be auto-detected from package.json)',
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'set_experience_level',
+                    description: 'Set the user experience level. This affects how detailed explanations are when building features. Use "beginner" for new developers who need more explanations, "intermediate" for developers who know the basics, or "advanced" for experienced developers who want minimal explanations.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            level: {
+                                type: 'string',
+                                enum: ['beginner', 'intermediate', 'advanced'],
+                                description: 'Experience level: beginner (detailed explanations), intermediate (balanced), advanced (minimal explanations)',
+                            },
+                        },
+                        required: ['level'],
+                    },
+                },
+                {
+                    name: 'get_experience_level',
+                    description: 'Get the current user experience level setting. Returns beginner, intermediate, or advanced. Use this at the start of building to know how much detail to include in explanations.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
             ],
         }));
         // Handle tool calls
@@ -378,6 +434,14 @@ class CodeBakersServer {
                     return this.handleSearchPatterns(args);
                 case 'get_pattern_section':
                     return this.handleGetPatternSection(args);
+                case 'scaffold_project':
+                    return this.handleScaffoldProject(args);
+                case 'init_project':
+                    return this.handleInitProject(args);
+                case 'set_experience_level':
+                    return this.handleSetExperienceLevel(args);
+                case 'get_experience_level':
+                    return this.handleGetExperienceLevel();
                 default:
                     throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
             }
@@ -733,6 +797,322 @@ Show the user what their simple request was expanded into, then proceed with the
             ],
         };
     }
+    async handleScaffoldProject(args) {
+        const { projectName, description } = args;
+        const cwd = process.cwd();
+        // Check if directory has files
+        const files = fs.readdirSync(cwd);
+        const hasFiles = files.filter(f => !f.startsWith('.')).length > 0;
+        if (hasFiles) {
+            // Check if it's already a CodeBakers project
+            if (fs.existsSync(path.join(cwd, 'CLAUDE.md'))) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# Project Already Exists\n\nThis directory already has a CodeBakers project. Use the existing project or navigate to an empty directory.`,
+                        }],
+                };
+            }
+        }
+        const results = [];
+        results.push(`# 🚀 Creating Project: ${projectName}\n`);
+        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 = path.join(cwd, dir);
+                if (!fs.existsSync(dirPath)) {
+                    fs.mkdirSync(dirPath, { recursive: true });
+                }
+            }
+            results.push('✓ Created directory structure');
+            // Write package.json
+            const packageJson = { ...templates.PACKAGE_JSON, name: projectName };
+            fs.writeFileSync(path.join(cwd, 'package.json'), JSON.stringify(packageJson, null, 2));
+            results.push('✓ Created package.json');
+            // Write config files
+            fs.writeFileSync(path.join(cwd, '.env.example'), templates.ENV_EXAMPLE);
+            fs.writeFileSync(path.join(cwd, '.env.local'), templates.ENV_EXAMPLE);
+            fs.writeFileSync(path.join(cwd, 'drizzle.config.ts'), templates.DRIZZLE_CONFIG);
+            fs.writeFileSync(path.join(cwd, 'tailwind.config.ts'), templates.TAILWIND_CONFIG);
+            fs.writeFileSync(path.join(cwd, 'postcss.config.mjs'), templates.POSTCSS_CONFIG);
+            fs.writeFileSync(path.join(cwd, 'tsconfig.json'), JSON.stringify(templates.TSCONFIG, null, 2));
+            fs.writeFileSync(path.join(cwd, 'next.config.ts'), templates.NEXT_CONFIG);
+            fs.writeFileSync(path.join(cwd, '.gitignore'), templates.GITIGNORE);
+            results.push('✓ Created configuration files');
+            // Write source files
+            fs.writeFileSync(path.join(cwd, 'src/lib/supabase/server.ts'), templates.SUPABASE_SERVER);
+            fs.writeFileSync(path.join(cwd, 'src/lib/supabase/client.ts'), templates.SUPABASE_CLIENT);
+            fs.writeFileSync(path.join(cwd, 'src/lib/supabase/middleware.ts'), templates.SUPABASE_MIDDLEWARE);
+            fs.writeFileSync(path.join(cwd, 'middleware.ts'), templates.MIDDLEWARE);
+            fs.writeFileSync(path.join(cwd, 'src/db/schema.ts'), templates.DB_SCHEMA);
+            fs.writeFileSync(path.join(cwd, 'src/db/index.ts'), templates.DB_INDEX);
+            fs.writeFileSync(path.join(cwd, 'src/app/globals.css'), templates.GLOBALS_CSS);
+            fs.writeFileSync(path.join(cwd, 'src/app/layout.tsx'), templates.LAYOUT_TSX);
+            fs.writeFileSync(path.join(cwd, 'src/app/page.tsx'), templates.PAGE_TSX);
+            fs.writeFileSync(path.join(cwd, 'src/lib/utils.ts'), templates.UTILS_CN);
+            results.push('✓ Created source files');
+            // Install dependencies
+            try {
+                (0, child_process_1.execSync)('npm install', { cwd, stdio: 'pipe' });
+                results.push('✓ Installed npm dependencies');
+            }
+            catch {
+                results.push('⚠️ Could not install dependencies - run `npm install` manually');
+            }
+            // Now install CodeBakers patterns
+            results.push('\n## Installing CodeBakers Patterns...\n');
+            const response = await fetch(`${this.apiUrl}/api/content`, {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${this.apiKey}` },
+            });
+            if (response.ok) {
+                const content = await response.json();
+                // Write CLAUDE.md
+                if (content.router) {
+                    fs.writeFileSync(path.join(cwd, 'CLAUDE.md'), content.router);
+                    results.push('✓ Created CLAUDE.md (AI router)');
+                }
+                // Write pattern modules
+                if (content.modules && Object.keys(content.modules).length > 0) {
+                    const modulesDir = path.join(cwd, '.claude');
+                    if (!fs.existsSync(modulesDir)) {
+                        fs.mkdirSync(modulesDir, { recursive: true });
+                    }
+                    for (const [name, data] of Object.entries(content.modules)) {
+                        fs.writeFileSync(path.join(modulesDir, name), data);
+                    }
+                    results.push(`✓ Installed ${Object.keys(content.modules).length} pattern modules`);
+                }
+                // Create PRD with description
+                const date = new Date().toISOString().split('T')[0];
+                const prdContent = `# Product Requirements Document
+# Project: ${projectName}
+# Created: ${date}
+
+## Overview
+**One-liner:** ${description || '[Describe this project in one sentence]'}
+
+**Problem:** [What problem does this solve?]
+
+**Solution:** [How does this solve it?]
+
+## Core Features (MVP)
+1. [ ] **Feature 1:** [Description]
+2. [ ] **Feature 2:** [Description]
+3. [ ] **Feature 3:** [Description]
+
+## Technical Requirements
+- Framework: Next.js 14 (App Router)
+- Database: PostgreSQL + Drizzle ORM
+- Auth: Supabase Auth
+- UI: Tailwind CSS + shadcn/ui
+
+---
+<!-- AI: Reference this PRD when building features -->
+`;
+                fs.writeFileSync(path.join(cwd, 'PRD.md'), prdContent);
+                results.push('✓ Created PRD.md');
+                // Create other project files
+                fs.writeFileSync(path.join(cwd, 'PROJECT-STATE.md'), `# PROJECT STATE
+# Last Updated: ${date}
+
+## Project Info
+name: ${projectName}
+phase: setup
+
+## In Progress
+## Completed
+## Next Up
+`);
+                results.push('✓ Created PROJECT-STATE.md');
+            }
+            results.push('\n---\n');
+            results.push('## ✅ Project Created Successfully!\n');
+            results.push('### Next Steps:\n');
+            results.push('1. **Set up Supabase:** Go to https://supabase.com and create a free project');
+            results.push('2. **Add credentials:** Copy your Supabase URL and anon key to `.env.local`');
+            results.push('3. **Start building:** Just tell me what features you want!\n');
+            results.push('### Example:\n');
+            results.push('> "Add user authentication with email/password"');
+            results.push('> "Create a dashboard with stats cards"');
+            results.push('> "Build a todo list with CRUD operations"');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            results.push(`\n❌ Error: ${message}`);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: results.join('\n'),
+                }],
+        };
+    }
+    async handleInitProject(args) {
+        const cwd = process.cwd();
+        const results = [];
+        // Detect project name from package.json
+        let projectName = args.projectName || 'my-project';
+        try {
+            const pkgPath = path.join(cwd, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                projectName = pkg.name || projectName;
+            }
+        }
+        catch {
+            // Use default
+        }
+        results.push(`# 🎨 Adding CodeBakers to: ${projectName}\n`);
+        // Check if already initialized
+        if (fs.existsSync(path.join(cwd, 'CLAUDE.md'))) {
+            results.push('⚠️ CLAUDE.md already exists. Updating patterns...\n');
+        }
+        try {
+            const response = await fetch(`${this.apiUrl}/api/content`, {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${this.apiKey}` },
+            });
+            if (!response.ok) {
+                throw new Error('Failed to fetch patterns from API');
+            }
+            const content = await response.json();
+            // Write CLAUDE.md
+            if (content.router) {
+                fs.writeFileSync(path.join(cwd, 'CLAUDE.md'), content.router);
+                results.push('✓ Created/Updated CLAUDE.md');
+            }
+            // Write pattern modules
+            if (content.modules && Object.keys(content.modules).length > 0) {
+                const modulesDir = path.join(cwd, '.claude');
+                if (!fs.existsSync(modulesDir)) {
+                    fs.mkdirSync(modulesDir, { recursive: true });
+                }
+                for (const [name, data] of Object.entries(content.modules)) {
+                    fs.writeFileSync(path.join(modulesDir, name), data);
+                }
+                results.push(`✓ Installed ${Object.keys(content.modules).length} pattern modules (v${content.version})`);
+            }
+            // Create PRD if doesn't exist
+            const date = new Date().toISOString().split('T')[0];
+            const prdPath = path.join(cwd, 'PRD.md');
+            if (!fs.existsSync(prdPath)) {
+                fs.writeFileSync(prdPath, `# Product Requirements Document
+# Project: ${projectName}
+# Created: ${date}
+
+## Overview
+**One-liner:** [Describe this project]
+
+## Core Features (MVP)
+1. [ ] **Feature 1:** [Description]
+2. [ ] **Feature 2:** [Description]
+`);
+                results.push('✓ Created PRD.md template');
+            }
+            // Create PROJECT-STATE if doesn't exist
+            const statePath = path.join(cwd, 'PROJECT-STATE.md');
+            if (!fs.existsSync(statePath)) {
+                fs.writeFileSync(statePath, `# PROJECT STATE
+# Last Updated: ${date}
+
+## Project Info
+name: ${projectName}
+phase: development
+
+## In Progress
+## Completed
+## Next Up
+`);
+                results.push('✓ Created PROJECT-STATE.md');
+            }
+            // Update .gitignore
+            const gitignorePath = path.join(cwd, '.gitignore');
+            if (fs.existsSync(gitignorePath)) {
+                const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+                if (!gitignore.includes('.claude/')) {
+                    fs.writeFileSync(gitignorePath, gitignore + '\n# CodeBakers\n.claude/\n');
+                    results.push('✓ Updated .gitignore');
+                }
+            }
+            results.push('\n---\n');
+            results.push('## ✅ CodeBakers Patterns Installed!\n');
+            results.push('The AI now has access to production patterns for:');
+            results.push('- Authentication, Database, API design');
+            results.push('- Frontend components, Forms, Validation');
+            results.push('- Payments, Email, Real-time features');
+            results.push('- And 30+ more specialized patterns\n');
+            results.push('Just describe what you want to build!');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            results.push(`\n❌ Error: ${message}`);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: results.join('\n'),
+                }],
+        };
+    }
+    handleSetExperienceLevel(args) {
+        const { level } = args;
+        // Validate level
+        if (!['beginner', 'intermediate', 'advanced'].includes(level)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Invalid experience level: "${level}". Must be: beginner, intermediate, or advanced.`,
+                    }],
+            };
+        }
+        (0, config_js_1.setExperienceLevel)(level);
+        const descriptions = {
+            beginner: '🎓 **Beginner Mode**\n\nI will:\n- Explain concepts as I go\n- Break down complex steps\n- Provide more context about what each piece of code does\n- Suggest learning resources when relevant',
+            intermediate: '⚡ **Intermediate Mode**\n\nI will:\n- Provide balanced explanations\n- Focus on the "why" behind decisions\n- Skip basic explanations you already know',
+            advanced: '🚀 **Advanced Mode**\n\nI will:\n- Skip explanations, just build\n- Focus on efficiency and best practices\n- Assume you know the fundamentals\n- Get straight to the code',
+        };
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Experience level set to: **${level}**\n\n${descriptions[level]}`,
+                }],
+        };
+    }
+    handleGetExperienceLevel() {
+        const level = (0, config_js_1.getExperienceLevel)();
+        const modeInfo = {
+            beginner: {
+                emoji: '🎓',
+                description: 'Detailed explanations, step-by-step guidance'
+            },
+            intermediate: {
+                emoji: '⚡',
+                description: 'Balanced explanations, focus on decisions'
+            },
+            advanced: {
+                emoji: '🚀',
+                description: 'Minimal explanations, straight to code'
+            },
+        };
+        const info = modeInfo[level];
+        return {
+            content: [{
+                    type: 'text',
+                    text: `# Current Experience Level\n\n${info.emoji} **${level.charAt(0).toUpperCase() + level.slice(1)}**\n${info.description}\n\n---\n\nTo change, use: \`set_experience_level\` with "beginner", "intermediate", or "advanced"`,
+                }],
+        };
+    }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebakers/cli",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "CodeBakers CLI - Production patterns for AI-assisted development",
   "main": "dist/index.js",
   "bin": {