@codebakers/cli 2.7.0 → 2.9.0

package/dist/mcp/server.js

@@ -509,7 +509,7 @@ class CodeBakersServer {
                 },
                 {
                     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.',
+                    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. Set fullDeploy=true for seamless idea-to-deployment (creates GitHub repo, Supabase project, and deploys to Vercel). When fullDeploy=true, first call returns explanation - then call again with deployConfirmed=true after user confirms.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -521,6 +521,14 @@ class CodeBakersServer {
                                 type: 'string',
                                 description: 'Brief description of what the project is for (used in PRD.md)',
                             },
+                            fullDeploy: {
+                                type: 'boolean',
+                                description: 'If true, enables full deployment flow (GitHub + Supabase + Vercel). First call returns explanation for user confirmation.',
+                            },
+                            deployConfirmed: {
+                                type: 'boolean',
+                                description: 'Set to true AFTER user confirms they want full deployment. Only set this after showing user the explanation and getting their approval.',
+                            },
                         },
                         required: ['projectName'],
                     },
@@ -1204,8 +1212,12 @@ Show the user what their simple request was expanded into, then proceed with the
         };
     }
     async handleScaffoldProject(args) {
-        const { projectName, description } = args;
+        const { projectName, description, fullDeploy, deployConfirmed } = args;
         const cwd = process.cwd();
+        // If fullDeploy requested but not confirmed, show explanation and ask for confirmation
+        if (fullDeploy && !deployConfirmed) {
+            return this.showFullDeployExplanation(projectName, description);
+        }
         // Check if directory has files
         const files = fs.readdirSync(cwd);
         const hasFiles = files.filter(f => !f.startsWith('.')).length > 0;
@@ -1344,14 +1356,22 @@ phase: setup
             }
             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"');
+            // If fullDeploy is enabled and confirmed, proceed with cloud deployment
+            if (fullDeploy && deployConfirmed) {
+                results.push('## 🚀 Starting Full Deployment...\n');
+                const deployResults = await this.executeFullDeploy(projectName, cwd, description);
+                results.push(...deployResults);
+            }
+            else {
+                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';
@@ -1364,6 +1384,270 @@ phase: setup
                 }],
         };
     }
+    /**
+     * Show explanation of what fullDeploy will do and ask for confirmation
+     */
+    showFullDeployExplanation(projectName, description) {
+        const explanation = `# 🚀 Full Deployment: ${projectName}
+
+## What This Will Do
+
+Full deployment creates a complete production-ready environment automatically:
+
+### 1. 📁 Local Project
+- Create Next.js + Supabase + Drizzle project
+- Install all dependencies
+- Set up CodeBakers patterns
+
+### 2. 🐙 GitHub Repository
+- Create a new private repository: \`${projectName}\`
+- Initialize git and push code
+- Set up .gitignore properly
+
+### 3. 🗄️ Supabase Project
+- Create a new Supabase project
+- Get database connection string
+- Get API keys (anon + service role)
+- Auto-configure .env.local
+
+### 4. 🔺 Vercel Deployment
+- Deploy to Vercel
+- Connect to GitHub for auto-deploys
+- Set all environment variables
+- Get your live URL
+
+---
+
+## Requirements
+
+Make sure you have these CLIs installed and authenticated:
+- \`gh\` - GitHub CLI (run: \`gh auth login\`)
+- \`supabase\` - Supabase CLI (run: \`supabase login\`)
+- \`vercel\` - Vercel CLI (run: \`vercel login\`)
+
+---
+
+## 🎯 Result
+
+After completion, you'll have:
+- ✅ GitHub repo with your code
+- ✅ Supabase project with database ready
+- ✅ Live URL on Vercel
+- ✅ Auto-deploys on every push
+
+---
+
+**⚠️ IMPORTANT: Ask the user to confirm before proceeding.**
+
+To proceed, call \`scaffold_project\` again with:
+\`\`\`json
+{
+  "projectName": "${projectName}",
+  "description": "${description || ''}",
+  "fullDeploy": true,
+  "deployConfirmed": true
+}
+\`\`\`
+
+Or if user declines, call without fullDeploy:
+\`\`\`json
+{
+  "projectName": "${projectName}",
+  "description": "${description || ''}"
+}
+\`\`\`
+`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: explanation,
+                }],
+        };
+    }
+    /**
+     * Execute full cloud deployment (GitHub + Supabase + Vercel)
+     */
+    async executeFullDeploy(projectName, cwd, description) {
+        const results = [];
+        // Check for required CLIs
+        const cliChecks = this.checkRequiredCLIs();
+        if (cliChecks.missing.length > 0) {
+            results.push('### ❌ Missing Required CLIs\n');
+            results.push('The following CLIs are required for full deployment:\n');
+            for (const cli of cliChecks.missing) {
+                results.push(`- **${cli.name}**: ${cli.installCmd}`);
+            }
+            results.push('\nInstall the missing CLIs and try again.');
+            return results;
+        }
+        results.push('✓ All required CLIs found\n');
+        // Step 1: Initialize Git and create GitHub repo
+        results.push('### Step 1: GitHub Repository\n');
+        try {
+            // Initialize git
+            (0, child_process_1.execSync)('git init', { cwd, stdio: 'pipe' });
+            (0, child_process_1.execSync)('git add .', { cwd, stdio: 'pipe' });
+            (0, child_process_1.execSync)('git commit -m "Initial commit from CodeBakers"', { cwd, stdio: 'pipe' });
+            results.push('✓ Initialized git repository');
+            // Create GitHub repo
+            const ghDescription = description || `${projectName} - Created with CodeBakers`;
+            (0, child_process_1.execSync)(`gh repo create ${projectName} --private --source=. --push --description "${ghDescription}"`, { cwd, stdio: 'pipe' });
+            results.push(`✓ Created GitHub repo: ${projectName}`);
+            results.push(`  → https://github.com/${this.getGitHubUsername()}/${projectName}\n`);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            results.push(`⚠️ GitHub setup failed: ${msg}`);
+            results.push('  You can create the repo manually: gh repo create\n');
+        }
+        // Step 2: Create Supabase project
+        results.push('### Step 2: Supabase Project\n');
+        try {
+            // Create Supabase project (this may take a while)
+            const orgId = this.getSupabaseOrgId();
+            if (orgId) {
+                (0, child_process_1.execSync)(`supabase projects create ${projectName} --org-id ${orgId} --region us-east-1 --db-password "${this.generatePassword()}"`, { cwd, stdio: 'pipe', timeout: 120000 });
+                results.push(`✓ Created Supabase project: ${projectName}`);
+                // Get project credentials
+                const projectsOutput = (0, child_process_1.execSync)('supabase projects list --output json', { cwd, encoding: 'utf-8' });
+                const projects = JSON.parse(projectsOutput);
+                const newProject = projects.find((p) => p.name === projectName);
+                if (newProject) {
+                    // Update .env.local with Supabase credentials
+                    const envPath = path.join(cwd, '.env.local');
+                    let envContent = fs.readFileSync(envPath, 'utf-8');
+                    envContent = envContent.replace('your-supabase-url', `https://${newProject.id}.supabase.co`);
+                    envContent = envContent.replace('your-anon-key', newProject.anon_key || 'YOUR_ANON_KEY');
+                    fs.writeFileSync(envPath, envContent);
+                    results.push('✓ Updated .env.local with Supabase credentials\n');
+                }
+            }
+            else {
+                results.push('⚠️ Could not detect Supabase organization');
+                results.push('  Run: supabase orgs list\n');
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            results.push(`⚠️ Supabase setup failed: ${msg}`);
+            results.push('  Create project manually at: https://supabase.com/dashboard\n');
+        }
+        // Step 3: Deploy to Vercel
+        results.push('### Step 3: Vercel Deployment\n');
+        try {
+            // Link to Vercel (creates new project)
+            (0, child_process_1.execSync)('vercel link --yes', { cwd, stdio: 'pipe' });
+            results.push('✓ Linked to Vercel');
+            // Set environment variables from .env.local
+            const envPath = path.join(cwd, '.env.local');
+            if (fs.existsSync(envPath)) {
+                const envContent = fs.readFileSync(envPath, 'utf-8');
+                const envVars = envContent.split('\n')
+                    .filter(line => line.includes('=') && !line.startsWith('#'))
+                    .map(line => {
+                    const [key, ...valueParts] = line.split('=');
+                    return { key: key.trim(), value: valueParts.join('=').trim() };
+                });
+                for (const { key, value } of envVars) {
+                    if (value && !value.includes('your-')) {
+                        try {
+                            (0, child_process_1.execSync)(`vercel env add ${key} production <<< "${value}"`, { cwd, stdio: 'pipe', shell: 'bash' });
+                        }
+                        catch {
+                            // Env var might already exist, try to update
+                        }
+                    }
+                }
+                results.push('✓ Set environment variables');
+            }
+            // Deploy to production
+            const deployOutput = (0, child_process_1.execSync)('vercel --prod --yes', { cwd, encoding: 'utf-8' });
+            const urlMatch = deployOutput.match(/https:\/\/[^\s]+\.vercel\.app/);
+            const deployUrl = urlMatch ? urlMatch[0] : 'Check Vercel dashboard';
+            results.push(`✓ Deployed to Vercel`);
+            results.push(`  → ${deployUrl}\n`);
+            // Connect to GitHub for auto-deploys
+            try {
+                (0, child_process_1.execSync)('vercel git connect --yes', { cwd, stdio: 'pipe' });
+                results.push('✓ Connected to GitHub for auto-deploys\n');
+            }
+            catch {
+                results.push('⚠️ Could not auto-connect to GitHub\n');
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            results.push(`⚠️ Vercel deployment failed: ${msg}`);
+            results.push('  Deploy manually: vercel --prod\n');
+        }
+        // Summary
+        results.push('---\n');
+        results.push('## 🎉 Full Deployment Complete!\n');
+        results.push('Your project is now live with:');
+        results.push('- GitHub repo with CI/CD ready');
+        results.push('- Supabase database configured');
+        results.push('- Vercel hosting with auto-deploys\n');
+        results.push('**Start building features - every push auto-deploys!**');
+        return results;
+    }
+    /**
+     * Check if required CLIs are installed
+     */
+    checkRequiredCLIs() {
+        const clis = [
+            { name: 'gh', cmd: 'gh --version', installCmd: 'npm install -g gh' },
+            { name: 'supabase', cmd: 'supabase --version', installCmd: 'npm install -g supabase' },
+            { name: 'vercel', cmd: 'vercel --version', installCmd: 'npm install -g vercel' },
+        ];
+        const installed = [];
+        const missing = [];
+        for (const cli of clis) {
+            try {
+                (0, child_process_1.execSync)(cli.cmd, { stdio: 'pipe' });
+                installed.push(cli.name);
+            }
+            catch {
+                missing.push({ name: cli.name, installCmd: cli.installCmd });
+            }
+        }
+        return { installed, missing };
+    }
+    /**
+     * Get GitHub username from gh CLI
+     */
+    getGitHubUsername() {
+        try {
+            const output = (0, child_process_1.execSync)('gh api user --jq .login', { encoding: 'utf-8' });
+            return output.trim();
+        }
+        catch {
+            return 'YOUR_USERNAME';
+        }
+    }
+    /**
+     * Get Supabase organization ID
+     */
+    getSupabaseOrgId() {
+        try {
+            const output = (0, child_process_1.execSync)('supabase orgs list --output json', { encoding: 'utf-8' });
+            const orgs = JSON.parse(output);
+            return orgs[0]?.id || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Generate a secure random password for Supabase
+     */
+    generatePassword() {
+        const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        let password = '';
+        for (let i = 0; i < 24; i++) {
+            password += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return password;
+    }
     async handleInitProject(args) {
         const cwd = process.cwd();
         const results = [];

package/package.json

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

package/src/commands/push-patterns.ts

@@ -0,0 +1,222 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { createInterface } from 'readline';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+import { getApiUrl, getApiKey } from '../config.js';
+
+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());
+    });
+  });
+}
+
+interface PushOptions {
+  version: string;
+  changelog?: string;
+  autoPublish?: boolean;
+  sourcePath?: string;
+}
+
+interface ModulesContent {
+  [key: string]: string;
+}
+
+/**
+ * Read all module files from a directory
+ */
+function readModulesFromDir(dirPath: string): ModulesContent {
+  const modules: ModulesContent = {};
+
+  if (!existsSync(dirPath)) {
+    return modules;
+  }
+
+  const files = readdirSync(dirPath).filter(f => f.endsWith('.md'));
+
+  for (const file of files) {
+    const filePath = join(dirPath, file);
+    const content = readFileSync(filePath, 'utf-8');
+    const moduleName = basename(file, '.md');
+    modules[moduleName] = content;
+  }
+
+  return modules;
+}
+
+/**
+ * Push patterns to the server via admin API
+ */
+export async function pushPatterns(options: PushOptions): Promise<void> {
+  console.log(chalk.blue('\n  CodeBakers Push Patterns\n'));
+
+  const sourcePath = options.sourcePath || process.cwd();
+
+  // Check for API key - first from config, then from environment
+  const apiKey = getApiKey() || process.env.CODEBAKERS_ADMIN_KEY;
+  if (!apiKey) {
+    console.log(chalk.red('  ✗ No API key found\n'));
+    console.log(chalk.gray('  Either:'));
+    console.log(chalk.cyan('    1. Run `codebakers setup` to configure your API key'));
+    console.log(chalk.cyan('    2. Set CODEBAKERS_ADMIN_KEY environment variable\n'));
+    process.exit(1);
+  }
+
+  // Read main files
+  const claudeMdPath = join(sourcePath, 'CLAUDE.md');
+  const cursorRulesPath = join(sourcePath, '.cursorrules');
+
+  let claudeMdContent: string | null = null;
+  let cursorRulesContent: string | null = null;
+
+  if (existsSync(claudeMdPath)) {
+    claudeMdContent = readFileSync(claudeMdPath, 'utf-8');
+    console.log(chalk.green(`  ✓ Found CLAUDE.md (${(claudeMdContent.length / 1024).toFixed(1)} KB)`));
+  } else {
+    console.log(chalk.yellow(`  ⚠ CLAUDE.md not found at ${claudeMdPath}`));
+  }
+
+  if (existsSync(cursorRulesPath)) {
+    cursorRulesContent = readFileSync(cursorRulesPath, 'utf-8');
+    console.log(chalk.green(`  ✓ Found .cursorrules (${(cursorRulesContent.length / 1024).toFixed(1)} KB)`));
+  } else {
+    console.log(chalk.yellow(`  ⚠ .cursorrules not found at ${cursorRulesPath}`));
+  }
+
+  if (!claudeMdContent && !cursorRulesContent) {
+    console.log(chalk.red('\n  ✗ No pattern files found. Nothing to push.\n'));
+    process.exit(1);
+  }
+
+  // Read module directories
+  const claudeModulesPath = join(sourcePath, '.claude');
+  const cursorModulesPath = join(sourcePath, '.cursorrules-modules');
+
+  const modulesContent = readModulesFromDir(claudeModulesPath);
+  const cursorModulesContent = readModulesFromDir(cursorModulesPath);
+
+  const claudeModuleCount = Object.keys(modulesContent).length;
+  const cursorModuleCount = Object.keys(cursorModulesContent).length;
+
+  if (claudeModuleCount > 0) {
+    console.log(chalk.green(`  ✓ Found ${claudeModuleCount} Claude modules in .claude/`));
+  }
+
+  if (cursorModuleCount > 0) {
+    console.log(chalk.green(`  ✓ Found ${cursorModuleCount} Cursor modules in .cursorrules-modules/`));
+  }
+
+  console.log('');
+
+  // Show summary
+  console.log(chalk.white('  Push Summary:\n'));
+  console.log(chalk.gray(`    Version:      ${chalk.cyan(options.version)}`));
+  console.log(chalk.gray(`    Auto-publish: ${options.autoPublish ? chalk.green('Yes') : chalk.yellow('No')}`));
+  if (options.changelog) {
+    console.log(chalk.gray(`    Changelog:    ${chalk.dim(options.changelog.slice(0, 60))}...`));
+  }
+  console.log('');
+
+  // Files to upload
+  console.log(chalk.white('  Files to upload:\n'));
+  if (claudeMdContent) console.log(chalk.cyan('    • CLAUDE.md'));
+  if (cursorRulesContent) console.log(chalk.cyan('    • .cursorrules'));
+  for (const mod of Object.keys(modulesContent)) {
+    console.log(chalk.dim(`    • .claude/${mod}.md`));
+  }
+  for (const mod of Object.keys(cursorModulesContent)) {
+    console.log(chalk.dim(`    • .cursorrules-modules/${mod}.md`));
+  }
+  console.log('');
+
+  // Confirm
+  const confirm = await prompt(chalk.gray('  Push these patterns? (y/N): '));
+  if (confirm.toLowerCase() !== 'y') {
+    console.log(chalk.gray('\n  Cancelled.\n'));
+    process.exit(0);
+  }
+
+  // Push to server
+  const spinner = ora('Pushing patterns to server...').start();
+
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/api/admin/content/push`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        version: options.version,
+        claudeMdContent,
+        cursorRulesContent,
+        modulesContent: claudeModuleCount > 0 ? modulesContent : undefined,
+        cursorModulesContent: cursorModuleCount > 0 ? cursorModulesContent : undefined,
+        changelog: options.changelog,
+        autoPublish: options.autoPublish,
+      }),
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      spinner.fail(chalk.red(`Push failed: ${data.error || 'Unknown error'}`));
+      process.exit(1);
+    }
+
+    spinner.succeed(chalk.green('Patterns pushed successfully!'));
+
+    console.log(chalk.white('\n  Result:\n'));
+    console.log(chalk.gray(`    Version ID:  ${chalk.cyan(data.version?.id || 'N/A')}`));
+    console.log(chalk.gray(`    Version:     ${chalk.cyan(data.version?.version || options.version)}`));
+    console.log(chalk.gray(`    Published:   ${data.published ? chalk.green('Yes') : chalk.yellow('No - run publish manually')}`));
+    console.log('');
+    console.log(chalk.green(`  ${data.message}\n`));
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to connect to server'));
+    console.log(chalk.gray(`\n  Error: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Interactive push command
+ */
+export async function pushPatternsInteractive(): Promise<void> {
+  console.log(chalk.blue('\n  CodeBakers Push Patterns\n'));
+
+  // Get version
+  const version = await prompt(chalk.cyan('  Version (e.g., 4.5): '));
+  if (!version) {
+    console.log(chalk.red('\n  Version is required.\n'));
+    process.exit(1);
+  }
+
+  // Get changelog
+  const changelog = await prompt(chalk.cyan('  Changelog (optional): '));
+
+  // Ask about auto-publish
+  const autoPublishAnswer = await prompt(chalk.cyan('  Auto-publish? (y/N): '));
+  const autoPublish = autoPublishAnswer.toLowerCase() === 'y';
+
+  // Get source path
+  const sourcePathAnswer = await prompt(chalk.cyan('  Source path (Enter for current directory): '));
+  const sourcePath = sourcePathAnswer || process.cwd();
+
+  await pushPatterns({
+    version,
+    changelog: changelog || undefined,
+    autoPublish,
+    sourcePath,
+  });
+}

package/src/commands/setup.ts

@@ -4,6 +4,7 @@ import { createInterface } from 'readline';
 import { execSync } from 'child_process';
 import { setApiKey, getApiKey, getApiUrl, syncServiceKeys, SERVICE_KEY_LABELS, type ServiceName } from '../config.js';
 import { validateApiKey, formatApiError, checkForUpdates, getCliVersion, type ApiError } from '../lib/api.js';
+import { showQuickStartGuide, formatFriendlyError, getNetworkError, getAuthError } from '../lib/progress.js';
 
 function prompt(question: string): Promise<string> {
   const rl = createInterface({
@@ -67,8 +68,16 @@ export async function setup(): Promise<void> {
   } catch (error) {
     spinner.fail('Invalid API key');
 
-    if (error && typeof error === 'object' && 'recoverySteps' in error) {
-      console.log(chalk.red(`\n  ${formatApiError(error as ApiError)}\n`));
+    // Use friendly error formatting
+    if (error && typeof error === 'object' && 'code' in error) {
+      const code = (error as { code: string }).code;
+      if (code === 'NETWORK_ERROR') {
+        console.log(formatFriendlyError(getNetworkError()));
+      } else if (code === 'UNAUTHORIZED' || code === 'INVALID_FORMAT') {
+        console.log(formatFriendlyError(getAuthError()));
+      } else if ('recoverySteps' in error) {
+        console.log(chalk.red(`\n  ${formatApiError(error as ApiError)}\n`));
+      }
     } else {
       const message = error instanceof Error ? error.message : 'API key validation failed';
       console.log(chalk.red(`\n  ${message}\n`));

package/src/index.ts

@@ -18,6 +18,7 @@ import { upgrade } from './commands/upgrade.js';
 import { config } from './commands/config.js';
 import { audit } from './commands/audit.js';
 import { heal, healWatch } from './commands/heal.js';
+import { pushPatterns, pushPatternsInteractive } from './commands/push-patterns.js';
 
 // Show welcome message when no command is provided
 function showWelcome(): void {
@@ -68,7 +69,7 @@ const program = new Command();
 program
   .name('codebakers')
   .description('CodeBakers CLI - Production patterns for AI-assisted development')
-  .version('1.7.0');
+  .version('2.9.0');
 
 // Primary command - one-time setup
 program
@@ -162,6 +163,27 @@ program
     }
   });
 
+// Admin commands
+program
+  .command('push-patterns')
+  .description('Push pattern files to the server (admin only)')
+  .option('-v, --version <version>', 'Version number (e.g., 4.5)')
+  .option('-c, --changelog <message>', 'Changelog message')
+  .option('-p, --publish', 'Auto-publish after push')
+  .option('-s, --source <path>', 'Source directory (default: current directory)')
+  .action(async (options) => {
+    if (options.version) {
+      await pushPatterns({
+        version: options.version,
+        changelog: options.changelog,
+        autoPublish: options.publish,
+        sourcePath: options.source,
+      });
+    } else {
+      await pushPatternsInteractive();
+    }
+  });
+
 // MCP Server commands
 program
   .command('serve')