@codebakers/cli 3.3.0 → 3.3.2

package/dist/mcp/server.js

@@ -89,6 +89,30 @@ class CodeBakersServer {
         }
         return {};
     }
+    /**
+     * Confirm download to server (non-blocking analytics)
+     */
+    async confirmDownload(version, moduleCount) {
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+                ...this.getAuthHeaders(),
+            };
+            await fetch(`${this.apiUrl}/api/content/confirm`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    version,
+                    moduleCount,
+                    cliVersion: (0, api_js_1.getCliVersion)(),
+                    command: 'auto-update',
+                }),
+            });
+        }
+        catch {
+            // Silently ignore - this is just for analytics
+        }
+    }
     /**
      * Automatically check for and apply pattern updates
      * Runs silently in background - no user intervention needed
@@ -178,6 +202,19 @@ class CodeBakersServer {
                 cliVersion: (0, api_js_1.getCliVersion)(),
             };
             fs.writeFileSync(versionPath, JSON.stringify(versionInfo, null, 2));
+            // Write notification file for AI to read and show to user
+            const notificationPath = path.join(claudeDir, '.update-notification.json');
+            const notification = {
+                type: 'patterns_updated',
+                previousVersion: installed?.version || 'unknown',
+                newVersion: content.version,
+                moduleCount,
+                updatedAt: new Date().toISOString(),
+                message: `CodeBakers patterns have been automatically updated from v${installed?.version || 'unknown'} to v${content.version} (${moduleCount} modules). Your AI tools now have the latest production patterns.`,
+            };
+            fs.writeFileSync(notificationPath, JSON.stringify(notification, null, 2));
+            // Confirm to server (non-blocking, fire-and-forget)
+            this.confirmDownload(content.version, moduleCount).catch(() => { });
             this.autoUpdateChecked = true;
             this.autoUpdateInProgress = false;
             // Log success (visible in MCP logs)
@@ -902,6 +939,27 @@ class CodeBakersServer {
                         required: ['request'],
                     },
                 },
+                {
+                    name: 'check_update_notification',
+                    description: 'ALWAYS CALL THIS AT THE START OF EACH SESSION. Checks if CodeBakers patterns were recently auto-updated and returns a notification message to show the user. If an update occurred, tell the user about it with the returned message. After showing, the notification is cleared.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                {
+                    name: 'update_patterns',
+                    description: 'Download and update CodeBakers pattern files from the server. Use when user says "upgrade codebakers", "update patterns", "download latest patterns", "sync codebakers", or when patterns are missing or outdated. This tool fetches the latest CLAUDE.md router and all .claude/ module files from the server and writes them to disk.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            force: {
+                                type: 'boolean',
+                                description: 'Force update even if already at latest version (default: false)',
+                            },
+                        },
+                    },
+                },
             ],
         }));
         // Handle tool calls
@@ -987,6 +1045,10 @@ class CodeBakersServer {
                     return this.handleAddPage(args);
                 case 'add_api_route':
                     return this.handleAddApiRoute(args);
+                case 'check_update_notification':
+                    return this.handleCheckUpdateNotification();
+                case 'update_patterns':
+                    return this.handleUpdatePatterns(args);
                 default:
                     throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
             }
@@ -4266,6 +4328,40 @@ export default ${asyncKeyword}function ${pageName}Page() {${authCheck}
                 }],
         };
     }
+    /**
+     * Check for update notifications and return message to show user
+     */
+    async handleCheckUpdateNotification() {
+        const cwd = process.cwd();
+        const notificationPath = path.join(cwd, '.claude', '.update-notification.json');
+        try {
+            if (!fs.existsSync(notificationPath)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: 'No update notification.',
+                        }],
+                };
+            }
+            const notification = JSON.parse(fs.readFileSync(notificationPath, 'utf-8'));
+            // Delete the notification file after reading (so it only shows once)
+            fs.unlinkSync(notificationPath);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `🍪 **CodeBakers Update**\n\n${notification.message}\n\n**Previous version:** ${notification.previousVersion}\n**New version:** ${notification.newVersion}\n**Modules:** ${notification.moduleCount}\n**Updated:** ${new Date(notification.updatedAt).toLocaleString()}`,
+                    }],
+            };
+        }
+        catch {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'No update notification.',
+                    }],
+            };
+        }
+    }
     parseApiRouteRequest(request) {
         const lower = request.toLowerCase();
         // Detect webhook
@@ -4451,6 +4547,137 @@ export async function POST(request: NextRequest) {
 ${handlers.join('\n')}
 `;
     }
+    /**
+     * Download and update CodeBakers patterns from server
+     * This is the MCP equivalent of the `codebakers upgrade` CLI command
+     */
+    async handleUpdatePatterns(args) {
+        const { force = false } = args;
+        const cwd = process.cwd();
+        const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+        const claudeDir = path.join(cwd, '.claude');
+        const versionPath = path.join(claudeDir, '.version.json');
+        let response = `# 🔄 CodeBakers Pattern Update\n\n`;
+        try {
+            // Check current version
+            let currentVersion = null;
+            let currentModuleCount = 0;
+            if (fs.existsSync(versionPath)) {
+                try {
+                    const versionInfo = JSON.parse(fs.readFileSync(versionPath, 'utf-8'));
+                    currentVersion = versionInfo.version;
+                    currentModuleCount = versionInfo.moduleCount || 0;
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+            // Count current modules
+            if (fs.existsSync(claudeDir)) {
+                try {
+                    const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.md'));
+                    currentModuleCount = files.length;
+                }
+                catch {
+                    // Ignore read errors
+                }
+            }
+            response += `## Current Status\n`;
+            response += `- Version: ${currentVersion || 'Unknown'}\n`;
+            response += `- Modules: ${currentModuleCount}\n\n`;
+            // Fetch latest version info first
+            const versionResponse = await fetch(`${this.apiUrl}/api/content/version`, {
+                headers: this.getAuthHeaders(),
+            });
+            if (!versionResponse.ok) {
+                throw new Error('Failed to check version from server');
+            }
+            const latestInfo = await versionResponse.json();
+            const latestVersion = latestInfo.version;
+            const latestModuleCount = latestInfo.moduleCount || 0;
+            response += `## Server Status\n`;
+            response += `- Latest Version: ${latestVersion}\n`;
+            response += `- Available Modules: ${latestModuleCount}\n\n`;
+            // Check if update needed
+            const needsUpdate = force || !currentVersion || currentVersion !== latestVersion || currentModuleCount < latestModuleCount;
+            if (!needsUpdate) {
+                response += `✅ **Already up to date!**\n\n`;
+                response += `Your patterns are current (v${latestVersion} with ${latestModuleCount} modules).\n`;
+                response += `Use \`force: true\` to re-download anyway.\n`;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: response,
+                        }],
+                };
+            }
+            response += `## Downloading Updates...\n\n`;
+            // Fetch full content
+            const contentResponse = await fetch(`${this.apiUrl}/api/content`, {
+                headers: this.getAuthHeaders(),
+            });
+            if (!contentResponse.ok) {
+                const error = await contentResponse.json().catch(() => ({}));
+                throw new Error(error.error || error.message || 'Failed to fetch patterns');
+            }
+            const content = await contentResponse.json();
+            const moduleCount = content.modules ? Object.keys(content.modules).length : 0;
+            // Create .claude directory if needed
+            if (!fs.existsSync(claudeDir)) {
+                fs.mkdirSync(claudeDir, { recursive: true });
+                response += `✓ Created .claude/ directory\n`;
+            }
+            // Update CLAUDE.md router
+            if (content.router) {
+                fs.writeFileSync(claudeMdPath, content.router);
+                response += `✓ Updated CLAUDE.md (router)\n`;
+            }
+            // Update all modules
+            if (content.modules && moduleCount > 0) {
+                for (const [name, data] of Object.entries(content.modules)) {
+                    fs.writeFileSync(path.join(claudeDir, name), data);
+                }
+                response += `✓ Updated ${moduleCount} modules in .claude/\n`;
+            }
+            // Save version info
+            const newVersionInfo = {
+                version: content.version || latestVersion,
+                moduleCount,
+                installedAt: currentVersion ? undefined : new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                cliVersion: (0, api_js_1.getCliVersion)(),
+            };
+            fs.writeFileSync(versionPath, JSON.stringify(newVersionInfo, null, 2));
+            response += `✓ Saved version info\n`;
+            // Confirm download to server (non-blocking analytics)
+            this.confirmDownload(content.version || latestVersion, moduleCount).catch(() => { });
+            response += `\n## ✅ Update Complete!\n\n`;
+            response += `- **From:** v${currentVersion || 'none'} (${currentModuleCount} modules)\n`;
+            response += `- **To:** v${content.version || latestVersion} (${moduleCount} modules)\n\n`;
+            if (moduleCount > currentModuleCount) {
+                response += `🆕 **${moduleCount - currentModuleCount} new modules added!**\n\n`;
+            }
+            response += `Your patterns are now up to date. The new patterns will be used in your next response.\n`;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            response += `\n## ❌ Update Failed\n\n`;
+            response += `Error: ${message}\n\n`;
+            if (message.includes('401') || message.includes('Invalid') || message.includes('expired')) {
+                response += `Your API key may be invalid or expired.\n`;
+                response += `Run \`codebakers setup\` in terminal to reconfigure.\n`;
+            }
+            else {
+                response += `Please try again or run \`codebakers upgrade\` in terminal.\n`;
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: response,
+                }],
+        };
+    }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);

package/nul

@@ -0,0 +1 @@
+vitest.config.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebakers/cli",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "CodeBakers CLI - Production patterns for AI-assisted development",
   "main": "dist/index.js",
   "bin": {
@@ -15,7 +15,8 @@
     "mcp": "tsx src/mcp/server.ts",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "postpublish": "node scripts/register-version.js"
   },
   "keywords": [
     "codebakers",

package/scripts/register-version.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+/**
+ * Automatically registers a new CLI version with the CodeBakers server
+ * Called automatically after npm publish via postpublish hook
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const API_URL = process.env.CODEBAKERS_API_URL || 'https://codebakers.ai';
+const ADMIN_API_KEY = process.env.CODEBAKERS_ADMIN_KEY;
+
+async function registerVersion() {
+  // Read version from package.json
+  const packagePath = path.join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+  const version = pkg.version;
+
+  console.log(`\n📦 Registering CLI version ${version} with CodeBakers server...\n`);
+
+  if (!ADMIN_API_KEY) {
+    console.log('⚠️  CODEBAKERS_ADMIN_KEY not set - skipping auto-registration');
+    console.log('   You can manually add this version in Admin → CLI Versions\n');
+    return;
+  }
+
+  try {
+    // Read changelog if it exists
+    let changelog = '';
+    const changelogPath = path.join(__dirname, '..', 'CHANGELOG.md');
+    if (fs.existsSync(changelogPath)) {
+      const content = fs.readFileSync(changelogPath, 'utf-8');
+      // Extract the latest version's changes
+      const match = content.match(/## \[?\d+\.\d+\.\d+\]?[^\n]*\n([\s\S]*?)(?=## \[?\d+\.\d+\.\d+|$)/);
+      if (match) {
+        changelog = match[1].trim().slice(0, 2000); // Limit length
+      }
+    }
+
+    const response = await fetch(`${API_URL}/api/cli/register-version`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${ADMIN_API_KEY}`,
+      },
+      body: JSON.stringify({
+        version,
+        npmTag: 'latest',
+        changelog,
+        minNodeVersion: '18',
+      }),
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      console.log(`✅ Version ${version} registered successfully!`);
+      console.log(`   Status: ${data.data?.version?.status || 'draft'}`);
+      console.log(`\n   Next steps:`);
+      console.log(`   1. Test the version`);
+      console.log(`   2. Go to Admin → CLI Versions`);
+      console.log(`   3. Promote to "testing" then "stable"`);
+      console.log(`   4. Enable auto-update when ready\n`);
+    } else {
+      const error = await response.json().catch(() => ({}));
+      if (error.error?.includes('already exists')) {
+        console.log(`ℹ️  Version ${version} already registered\n`);
+      } else {
+        console.log(`⚠️  Failed to register: ${error.error || response.statusText}`);
+        console.log(`   You can manually add this version in Admin → CLI Versions\n`);
+      }
+    }
+  } catch (error) {
+    console.log(`⚠️  Could not reach server: ${error.message}`);
+    console.log(`   You can manually add this version in Admin → CLI Versions\n`);
+  }
+}
+
+registerVersion();

package/src/commands/doctor.ts

@@ -5,6 +5,7 @@ import { homedir } from 'os';
 import { isHookInstalled } from './install-hook.js';
 import { getApiKey } from '../config.js';
 import { checkApiKeyValidity, checkForUpdates, getCliVersion } from '../lib/api.js';
+import { CODEBAKERS_STATS } from '../lib/stats.js';
 
 interface CheckResult {
   ok: boolean;
@@ -134,18 +135,18 @@ function checkProject(): CheckResult[] {
       const files = readdirSync(claudeDir).filter(f => f.endsWith('.md'));
       const moduleCount = files.length;
 
-      if (moduleCount >= 40) {
+      if (moduleCount >= 50) {
         results.push({ ok: true, message: `${moduleCount} modules present (full set)` });
       } else if (moduleCount >= 10) {
         results.push({
           ok: true,
           message: `${moduleCount} modules present (partial set)`,
-          details: 'Run: codebakers upgrade to get all 47 modules'
+          details: `Run: codebakers upgrade to get all ${CODEBAKERS_STATS.moduleCount} modules`
         });
       } else if (moduleCount > 0) {
         results.push({
           ok: false,
-          message: `Only ${moduleCount} modules found (expected 47)`,
+          message: `Only ${moduleCount} modules found (expected ${CODEBAKERS_STATS.moduleCount})`,
           details: 'Run: codebakers upgrade to get all modules'
         });
       } else {

package/src/commands/go.ts

@@ -39,6 +39,57 @@ interface GoOptions {
   verbose?: boolean;
 }
 
+interface ConfirmData {
+  version: string;
+  moduleCount: number;
+  cliVersion?: string;
+  command: string;
+  projectName?: string;
+}
+
+interface AuthInfo {
+  apiKey?: string;
+  trialId?: string;
+}
+
+/**
+ * Get CLI version from package.json
+ */
+function getCliVersion(): string {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const pkg = require('../../package.json');
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Confirm download to server (non-blocking, fire-and-forget)
+ */
+async function confirmDownload(apiUrl: string, auth: AuthInfo, data: ConfirmData): Promise<void> {
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (auth.apiKey) {
+      headers['Authorization'] = `Bearer ${auth.apiKey}`;
+    }
+    if (auth.trialId) {
+      headers['X-Trial-ID'] = auth.trialId;
+    }
+
+    await fetch(`${apiUrl}/api/content/confirm`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(data),
+    });
+  } catch {
+    // Silently ignore - this is just for analytics
+  }
+}
+
 function log(message: string, options?: GoOptions): void {
   if (options?.verbose) {
     console.log(chalk.gray(`  [verbose] ${message}`));
@@ -317,7 +368,7 @@ async function installPatternsWithApiKey(apiKey: string, options: GoOptions = {}
     log('Response OK, parsing JSON...', options);
     const content: ContentResponse = await response.json();
     log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-    await writePatternFiles(cwd, content, spinner, options);
+    await writePatternFiles(cwd, content, spinner, options, { apiKey });
 
   } catch (error) {
     log(`Error: ${error instanceof Error ? error.message : String(error)}`, options);
@@ -363,13 +414,13 @@ async function installPatterns(trialId: string, options: GoOptions = {}): Promis
 
       const content: ContentResponse = await publicResponse.json();
       log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-      await writePatternFiles(cwd, content, spinner, options);
+      await writePatternFiles(cwd, content, spinner, options, { trialId });
       return;
     }
 
     const content: ContentResponse = await response.json();
     log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-    await writePatternFiles(cwd, content, spinner, options);
+    await writePatternFiles(cwd, content, spinner, options, { trialId });
 
   } catch (error) {
     log(`Error: ${error instanceof Error ? error.message : String(error)}`, options);
@@ -378,7 +429,13 @@ async function installPatterns(trialId: string, options: GoOptions = {}): Promis
   }
 }
 
-async function writePatternFiles(cwd: string, content: ContentResponse, spinner: ReturnType<typeof ora>, options: GoOptions = {}): Promise<void> {
+async function writePatternFiles(
+  cwd: string,
+  content: ContentResponse,
+  spinner: ReturnType<typeof ora>,
+  options: GoOptions = {},
+  auth?: AuthInfo
+): Promise<void> {
   log(`Writing pattern files to ${cwd}...`, options);
   // Check if patterns already exist
   const claudeMdPath = join(cwd, 'CLAUDE.md');
@@ -393,7 +450,8 @@ async function writePatternFiles(cwd: string, content: ContentResponse, spinner:
   }
 
   // Write pattern modules to .claude/
-  if (content.modules && Object.keys(content.modules).length > 0) {
+  const moduleCount = Object.keys(content.modules || {}).length;
+  if (content.modules && moduleCount > 0) {
     const modulesDir = join(cwd, '.claude');
     if (!existsSync(modulesDir)) {
       mkdirSync(modulesDir, { recursive: true });
@@ -415,5 +473,16 @@ async function writePatternFiles(cwd: string, content: ContentResponse, spinner:
   }
 
   spinner.succeed(`CodeBakers patterns installed (v${content.version})`);
-  console.log(chalk.gray(`  ${Object.keys(content.modules || {}).length} pattern modules ready\n`));
+  console.log(chalk.gray(`  ${moduleCount} pattern modules ready\n`));
+
+  // Confirm download to server (non-blocking)
+  if (auth) {
+    const apiUrl = getApiUrl();
+    confirmDownload(apiUrl, auth, {
+      version: content.version,
+      moduleCount,
+      cliVersion: getCliVersion(),
+      command: 'go',
+    }).catch(() => {}); // Silently ignore
+  }
 }

package/src/commands/install.ts

@@ -4,6 +4,7 @@ import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { getApiKey, getApiUrl } from '../config.js';
 import { getCliVersion } from '../lib/api.js';
+import { CODEBAKERS_STATS } from '../lib/stats.js';
 
 interface ContentResponse {
   version: string;
@@ -94,7 +95,7 @@ export async function install(): Promise<void> {
     if (moduleCount > 0) {
       console.log(chalk.gray(`    - .claude/ (${moduleCount} pattern modules)`));
     }
-    console.log(chalk.blue('\n  Start building! Your AI now knows 114 production patterns.\n'));
+    console.log(chalk.blue(`\n  Start building! Your AI now knows ${CODEBAKERS_STATS.moduleCount} production modules.\n`));
   } catch (error) {
     spinner.fail('Installation failed');
     const message = error instanceof Error ? error.message : 'Unknown error';

package/src/commands/upgrade.ts

@@ -11,6 +11,32 @@ interface ContentResponse {
   modules: Record<string, string>;
 }
 
+interface ConfirmData {
+  version: string;
+  moduleCount: number;
+  cliVersion: string;
+  command: string;
+  projectName?: string;
+}
+
+/**
+ * Confirm download to server (non-blocking, fire-and-forget)
+ */
+async function confirmDownload(apiUrl: string, apiKey: string, data: ConfirmData): Promise<void> {
+  try {
+    await fetch(`${apiUrl}/api/content/confirm`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(data),
+    });
+  } catch {
+    // Silently ignore - this is just for analytics
+  }
+}
+
 /**
  * Upgrade CodeBakers patterns to the latest version
  */
@@ -101,6 +127,14 @@ export async function upgrade(): Promise<void> {
     writeFileSync(join(claudeDir, '.version.json'), JSON.stringify(versionInfo, null, 2));
     console.log(chalk.green('  ✓ Version info saved'));
 
+    // Confirm download to server (non-blocking)
+    confirmDownload(apiUrl, apiKey, {
+      version: content.version,
+      moduleCount,
+      cliVersion: getCliVersion(),
+      command: 'upgrade',
+    }).catch(() => {}); // Silently ignore confirmation failures
+
     console.log(chalk.green(`\n  ✅ Upgraded to patterns v${content.version}!\n`));
 
     // Show what's new if available