@codebakers/cli 1.1.4 → 1.1.6

package/dist/mcp/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,544 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServer = runServer;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+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"));
+// Pattern cache to avoid repeated API calls
+const patternCache = new Map();
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+class CodeBakersServer {
+    server;
+    apiKey;
+    apiUrl;
+    constructor() {
+        this.apiKey = (0, config_js_1.getApiKey)();
+        this.apiUrl = (0, config_js_1.getApiUrl)();
+        this.server = new index_js_1.Server({
+            name: 'codebakers',
+            version: '1.0.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupHandlers();
+    }
+    gatherProjectContext() {
+        const cwd = process.cwd();
+        const context = {
+            projectName: 'Unknown',
+            dependencies: [],
+            devDependencies: [],
+            folderStructure: [],
+            hasAuth: false,
+            hasDatabase: false,
+            hasPayments: false,
+            uiLibrary: null,
+            schemaPath: null,
+            componentsPath: null,
+            existingComponents: [],
+            existingServices: [],
+            existingApiRoutes: [],
+            codebakersState: null,
+        };
+        // Read package.json
+        try {
+            const pkgPath = path.join(cwd, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                context.projectName = pkg.name || 'Unknown';
+                context.dependencies = Object.keys(pkg.dependencies || {});
+                context.devDependencies = Object.keys(pkg.devDependencies || {});
+                // Detect libraries
+                const allDeps = [...context.dependencies, ...context.devDependencies];
+                context.hasAuth = allDeps.some(d => d.includes('supabase') || d.includes('next-auth') || d.includes('clerk'));
+                context.hasDatabase = allDeps.some(d => d.includes('drizzle') || d.includes('prisma') || d.includes('postgres'));
+                context.hasPayments = allDeps.some(d => d.includes('stripe') || d.includes('paypal'));
+                if (allDeps.includes('@radix-ui/react-dialog') || allDeps.some(d => d.includes('shadcn'))) {
+                    context.uiLibrary = 'shadcn/ui';
+                }
+                else if (allDeps.includes('@chakra-ui/react')) {
+                    context.uiLibrary = 'Chakra UI';
+                }
+                else if (allDeps.includes('@mui/material')) {
+                    context.uiLibrary = 'Material UI';
+                }
+            }
+        }
+        catch {
+            // Ignore package.json errors
+        }
+        // Read .codebakers.json state
+        try {
+            const statePath = path.join(cwd, '.codebakers.json');
+            if (fs.existsSync(statePath)) {
+                context.codebakersState = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            }
+        }
+        catch {
+            // Ignore state file errors
+        }
+        // Scan folder structure
+        const scanDir = (dir, prefix = '') => {
+            const results = [];
+            try {
+                if (!fs.existsSync(dir))
+                    return results;
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                        continue;
+                    const fullPath = path.join(prefix, entry.name);
+                    if (entry.isDirectory()) {
+                        results.push(fullPath + '/');
+                        // Only go 2 levels deep
+                        if (prefix.split('/').length < 2) {
+                            results.push(...scanDir(path.join(dir, entry.name), fullPath));
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore scan errors
+            }
+            return results;
+        };
+        context.folderStructure = scanDir(cwd);
+        // Find schema path
+        const schemaPaths = [
+            'src/db/schema.ts',
+            'src/lib/db/schema.ts',
+            'db/schema.ts',
+            'prisma/schema.prisma',
+            'drizzle/schema.ts',
+        ];
+        for (const schemaPath of schemaPaths) {
+            if (fs.existsSync(path.join(cwd, schemaPath))) {
+                context.schemaPath = schemaPath;
+                break;
+            }
+        }
+        // Find components path and list components
+        const componentPaths = ['src/components', 'components', 'app/components'];
+        for (const compPath of componentPaths) {
+            const fullPath = path.join(cwd, compPath);
+            if (fs.existsSync(fullPath)) {
+                context.componentsPath = compPath;
+                try {
+                    const scanComponents = (dir, prefix = '') => {
+                        const comps = [];
+                        const entries = fs.readdirSync(dir, { withFileTypes: true });
+                        for (const entry of entries) {
+                            if (entry.name.startsWith('.'))
+                                continue;
+                            if (entry.isDirectory()) {
+                                comps.push(...scanComponents(path.join(dir, entry.name), entry.name + '/'));
+                            }
+                            else if (entry.name.endsWith('.tsx') || entry.name.endsWith('.jsx')) {
+                                comps.push(prefix + entry.name.replace(/\.(tsx|jsx)$/, ''));
+                            }
+                        }
+                        return comps;
+                    };
+                    context.existingComponents = scanComponents(fullPath).slice(0, 50); // Limit to 50
+                }
+                catch {
+                    // Ignore component scan errors
+                }
+                break;
+            }
+        }
+        // Find services
+        const servicePaths = ['src/services', 'src/lib/services', 'services'];
+        for (const servPath of servicePaths) {
+            const fullPath = path.join(cwd, servPath);
+            if (fs.existsSync(fullPath)) {
+                try {
+                    const entries = fs.readdirSync(fullPath);
+                    context.existingServices = entries
+                        .filter(e => e.endsWith('.ts') || e.endsWith('.js'))
+                        .map(e => e.replace(/\.(ts|js)$/, ''))
+                        .slice(0, 20);
+                }
+                catch {
+                    // Ignore service scan errors
+                }
+                break;
+            }
+        }
+        // Find API routes
+        const apiPaths = ['src/app/api', 'app/api', 'pages/api'];
+        for (const apiPath of apiPaths) {
+            const fullPath = path.join(cwd, apiPath);
+            if (fs.existsSync(fullPath)) {
+                try {
+                    const scanApiRoutes = (dir, prefix = '') => {
+                        const routes = [];
+                        const entries = fs.readdirSync(dir, { withFileTypes: true });
+                        for (const entry of entries) {
+                            if (entry.name.startsWith('.'))
+                                continue;
+                            if (entry.isDirectory()) {
+                                routes.push(...scanApiRoutes(path.join(dir, entry.name), prefix + '/' + entry.name));
+                            }
+                            else if (entry.name === 'route.ts' || entry.name === 'route.js') {
+                                routes.push(prefix || '/');
+                            }
+                        }
+                        return routes;
+                    };
+                    context.existingApiRoutes = scanApiRoutes(fullPath).slice(0, 30);
+                }
+                catch {
+                    // Ignore API route scan errors
+                }
+                break;
+            }
+        }
+        return context;
+    }
+    formatContextForPrompt(context) {
+        const lines = [];
+        lines.push(`Project: ${context.projectName}`);
+        if (context.uiLibrary) {
+            lines.push(`UI Library: ${context.uiLibrary}`);
+        }
+        if (context.schemaPath) {
+            lines.push(`Database Schema: ${context.schemaPath}`);
+        }
+        if (context.componentsPath && context.existingComponents.length > 0) {
+            lines.push(`Components Path: ${context.componentsPath}`);
+            lines.push(`Existing Components: ${context.existingComponents.slice(0, 20).join(', ')}`);
+        }
+        if (context.existingServices.length > 0) {
+            lines.push(`Existing Services: ${context.existingServices.join(', ')}`);
+        }
+        if (context.existingApiRoutes.length > 0) {
+            lines.push(`Existing API Routes: ${context.existingApiRoutes.join(', ')}`);
+        }
+        const features = [];
+        if (context.hasAuth)
+            features.push('auth');
+        if (context.hasDatabase)
+            features.push('database');
+        if (context.hasPayments)
+            features.push('payments');
+        if (features.length > 0) {
+            lines.push(`Has: ${features.join(', ')}`);
+        }
+        const relevantDeps = context.dependencies.filter(d => ['next', 'react', 'drizzle-orm', 'stripe', '@supabase/supabase-js', 'zod', 'react-hook-form', 'tailwindcss'].some(rd => d.includes(rd)));
+        if (relevantDeps.length > 0) {
+            lines.push(`Key Dependencies: ${relevantDeps.join(', ')}`);
+        }
+        return lines.join('\n');
+    }
+    setupHandlers() {
+        // List available tools
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'optimize_and_build',
+                    description: 'ALWAYS USE THIS FIRST for any coding request. Takes a simple user request, uses AI to analyze intent and detect relevant patterns, optimizes it into a production-ready prompt, and returns everything needed to build the feature correctly. No keyword matching - AI understands what you actually want to build.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            request: {
+                                type: 'string',
+                                description: 'The user\'s original request (e.g., "add login", "create checkout", "zoom animation on image")',
+                            },
+                        },
+                        required: ['request'],
+                    },
+                },
+                {
+                    name: 'get_pattern',
+                    description: 'Fetch a single CodeBakers pattern module by name. Use optimize_and_build instead for automatic pattern detection.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            pattern: {
+                                type: 'string',
+                                description: 'Pattern name (e.g., "00-core", "01-database", "02-auth", "03-api", "04-frontend")',
+                            },
+                        },
+                        required: ['pattern'],
+                    },
+                },
+                {
+                    name: 'list_patterns',
+                    description: 'List all available CodeBakers pattern modules.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                {
+                    name: 'get_patterns',
+                    description: 'Fetch multiple CodeBakers patterns at once. Use optimize_and_build instead for automatic pattern detection.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            patterns: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Array of pattern names to fetch (max 5)',
+                            },
+                        },
+                        required: ['patterns'],
+                    },
+                },
+            ],
+        }));
+        // Handle tool calls
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            if (!this.apiKey) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, 'Not logged in. Run `codebakers login` first.');
+            }
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case 'optimize_and_build':
+                    return this.handleOptimizeAndBuild(args);
+                case 'get_pattern':
+                    return this.handleGetPattern(args);
+                case 'list_patterns':
+                    return this.handleListPatterns();
+                case 'get_patterns':
+                    return this.handleGetPatterns(args);
+                default:
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+            }
+        });
+    }
+    async handleOptimizeAndBuild(args) {
+        const { request: userRequest } = args;
+        // Step 1: Gather project context
+        const context = this.gatherProjectContext();
+        const contextSummary = this.formatContextForPrompt(context);
+        // Step 2: Call API to optimize the prompt with context
+        // The API uses AI to analyze intent and detect patterns (no keyword matching)
+        const optimizeResponse = await fetch(`${this.apiUrl}/api/optimize-prompt`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                prompt: userRequest,
+                context: {
+                    summary: contextSummary,
+                    projectName: context.projectName,
+                    uiLibrary: context.uiLibrary,
+                    schemaPath: context.schemaPath,
+                    componentsPath: context.componentsPath,
+                    existingComponents: context.existingComponents.slice(0, 30),
+                    existingServices: context.existingServices,
+                    existingApiRoutes: context.existingApiRoutes,
+                    hasAuth: context.hasAuth,
+                    hasDatabase: context.hasDatabase,
+                    hasPayments: context.hasPayments,
+                    dependencies: context.dependencies.slice(0, 30),
+                },
+            }),
+        });
+        // Default values if API fails
+        let optimizedPrompt = userRequest;
+        let detectedFeature = 'Feature';
+        let patterns = ['00-core', '04-frontend']; // Default fallback
+        if (optimizeResponse.ok) {
+            const optimizeData = await optimizeResponse.json();
+            optimizedPrompt = optimizeData.optimizedPrompt || userRequest;
+            detectedFeature = optimizeData.featureName || 'Feature';
+            // Use AI-detected patterns from the API (no local keyword matching)
+            patterns = optimizeData.patterns || ['00-core', '04-frontend'];
+        }
+        // Step 3: Fetch all relevant patterns (as detected by AI)
+        const patternResult = await this.fetchPatterns(patterns);
+        // Step 4: Build the response showing the optimization with context
+        const patternContent = Object.entries(patternResult.patterns || {})
+            .map(([name, text]) => `## ${name}\n\n${text}`)
+            .join('\n\n---\n\n');
+        const response = `# 🪄 Prompt Optimizer (AI-Powered Intent Analysis)
+
+## Your Request
+"${userRequest}"
+
+## Project Context Detected
+${contextSummary}
+
+## AI Analysis
+- **Detected Intent:** ${detectedFeature}
+- **Relevant Patterns:** ${patterns.join(', ')}
+
+## Optimized Prompt (Production-Ready)
+${optimizedPrompt}
+
+---
+
+# Pattern Documentation
+
+${patternContent}
+
+---
+
+**IMPORTANT:** Use the optimized prompt above as your guide. It is tailored to THIS project's structure, existing components, and conventions. The AI analyzed your intent (not just keywords) to select the right patterns. The prompt includes:
+- References to existing components and services you should reuse
+- The correct file paths for this project
+- Production requirements (error handling, loading states, validation, tests)
+
+Show the user what their simple request was expanded into, then proceed with the implementation following the patterns above.`;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: response,
+                },
+            ],
+        };
+    }
+    async handleGetPattern(args) {
+        const { pattern } = args;
+        // Check cache first
+        const cached = patternCache.get(pattern);
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: cached.content,
+                    },
+                ],
+            };
+        }
+        // Fetch from API
+        const result = await this.fetchPatterns([pattern]);
+        if (result.patterns && result.patterns[pattern]) {
+            const content = result.patterns[pattern];
+            // Cache the result
+            patternCache.set(pattern, { content, timestamp: Date.now() });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: content,
+                    },
+                ],
+            };
+        }
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Pattern "${pattern}" not found. Use list_patterns to see available patterns.`);
+    }
+    async handleListPatterns() {
+        const response = await fetch(`${this.apiUrl}/api/patterns`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error.error || 'Failed to fetch patterns');
+        }
+        const data = await response.json();
+        const patternList = data.patterns
+            .map((p) => `- ${p.name}`)
+            .join('\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Available CodeBakers Patterns (${data.total} total):\n\n${patternList}\n\nTip: Use optimize_and_build for automatic AI-powered pattern detection.`,
+                },
+            ],
+        };
+    }
+    async handleGetPatterns(args) {
+        const { patterns } = args;
+        if (patterns.length > 5) {
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, 'Maximum 5 patterns per request');
+        }
+        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',
+                    text: content ||
+                        'No patterns found. Use list_patterns to see available patterns.',
+                },
+            ],
+        };
+    }
+    async fetchPatterns(patterns) {
+        const response = await fetch(`${this.apiUrl}/api/patterns`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({ patterns }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error.error || 'Failed to fetch patterns');
+        }
+        return response.json();
+    }
+    async run() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        // Log to stderr so it doesn't interfere with stdio protocol
+        console.error('CodeBakers MCP server running on stdio');
+    }
+}
+// Export function for programmatic usage
+async function runServer() {
+    const server = new CodeBakersServer();
+    await server.run();
+}
+// Run directly if executed as main module
+const isMain = process.argv[1]?.includes('server');
+if (isMain) {
+    runServer().catch((error) => {
+        console.error('Failed to start MCP server:', error);
+        process.exit(1);
+    });
+}

package/package.json

@@ -1,61 +1,39 @@
 {
   "name": "@codebakers/cli",
-  "version": "1.1.4",
-  "description": "CodeBakers CLI - AI prompt patterns for production-ready code",
+  "version": "1.1.6",
+  "description": "CodeBakers CLI - Production patterns for AI-assisted development",
   "main": "dist/index.js",
   "bin": {
-    "codebakers": "dist/index.js"
+    "codebakers": "./dist/index.js",
+    "codebakers-mcp": "./dist/mcp/server.js"
   },
-  "type": "module",
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --watch",
-    "prepublishOnly": "npm run build",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "test:unit": "vitest run tests/unit",
-    "test:integration": "vitest run tests/integration"
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "mcp": "tsx src/mcp/server.ts"
   },
-  "files": [
-    "dist"
-  ],
   "keywords": [
     "codebakers",
     "ai",
-    "prompts",
     "cursor",
     "claude",
-    "aider",
-    "windsurf",
-    "mcp",
-    "cli"
+    "patterns",
+    "mcp"
   ],
   "author": "CodeBakers",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/codebakers/cli"
-  },
-  "homepage": "https://codebakers.ai",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "conf": "^12.0.0",
-    "inquirer": "^9.2.23",
-    "node-fetch": "^3.3.2",
-    "ora": "^8.0.1"
+    "conf": "^13.0.1",
+    "ora": "^8.1.1",
+    "openai": "^4.77.0"
   },
   "devDependencies": {
-    "@types/inquirer": "^9.0.7",
-    "@types/node": "^20.11.0",
-    "@vitest/coverage-v8": "^1.2.0",
-    "tsup": "^8.0.2",
-    "typescript": "^5.3.3",
-    "vitest": "^1.2.0"
-  },
-  "engines": {
-    "node": ">=18"
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
   }
 }