@codebakers/cli 2.6.2 → 2.8.0

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.8.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')

package/src/lib/progress.ts

@@ -0,0 +1,192 @@
+import chalk from 'chalk';
+import ora, { Ora } from 'ora';
+
+/**
+ * Multi-step progress tracker for CLI operations
+ */
+export interface Step {
+  name: string;
+  action: () => Promise<void>;
+}
+
+export class ProgressTracker {
+  private currentStep = 0;
+  private totalSteps: number;
+  private steps: Step[];
+  private spinner: Ora | null = null;
+
+  constructor(steps: Step[]) {
+    this.steps = steps;
+    this.totalSteps = steps.length;
+  }
+
+  async run(): Promise<void> {
+    for (let i = 0; i < this.steps.length; i++) {
+      this.currentStep = i + 1;
+      const step = this.steps[i];
+
+      this.spinner = ora({
+        text: this.formatStepText(step.name),
+        prefixText: this.formatPrefix(),
+      }).start();
+
+      try {
+        await step.action();
+        this.spinner.succeed(this.formatStepText(step.name));
+      } catch (error) {
+        this.spinner.fail(this.formatStepText(step.name));
+        throw error;
+      }
+    }
+  }
+
+  private formatPrefix(): string {
+    return chalk.gray(`  [${this.currentStep}/${this.totalSteps}]`);
+  }
+
+  private formatStepText(text: string): string {
+    return text;
+  }
+}
+
+/**
+ * Show a success box after completing a command
+ */
+export function showSuccessBox(title: string, lines: string[]): void {
+  const maxLength = Math.max(title.length, ...lines.map(l => l.length)) + 4;
+  const border = '═'.repeat(maxLength);
+
+  console.log(chalk.green(`\n  ╔${border}╗`));
+  console.log(chalk.green(`  ║`) + chalk.bold.white(` ${title.padEnd(maxLength - 2)} `) + chalk.green(`║`));
+  console.log(chalk.green(`  ╠${border}╣`));
+
+  for (const line of lines) {
+    console.log(chalk.green(`  ║`) + chalk.white(` ${line.padEnd(maxLength - 2)} `) + chalk.green(`║`));
+  }
+
+  console.log(chalk.green(`  ╚${border}╝\n`));
+}
+
+/**
+ * Display a quick start guide with examples
+ */
+export function showQuickStartGuide(): void {
+  console.log(chalk.blue('\n  ═══════════════════════════════════════════════════════════'));
+  console.log(chalk.bold.white('\n  📚 Quick Start Guide\n'));
+  console.log(chalk.blue('  ═══════════════════════════════════════════════════════════\n'));
+
+  console.log(chalk.white('  Just ask the AI in natural language:\n'));
+
+  const examples = [
+    {
+      prompt: '"Build me a user dashboard with stats cards"',
+      desc: 'AI will use CodeBakers patterns for layout, components, and data fetching',
+    },
+    {
+      prompt: '"Add Stripe subscription to my app"',
+      desc: 'AI loads payment patterns: checkout, webhooks, customer portal',
+    },
+    {
+      prompt: '"Create an API endpoint for user profiles"',
+      desc: 'AI generates: route handler, validation, error handling, types',
+    },
+    {
+      prompt: '"Set up auth with Google and email login"',
+      desc: 'AI implements OAuth + email auth following security patterns',
+    },
+  ];
+
+  for (const example of examples) {
+    console.log(chalk.cyan(`  → ${example.prompt}`));
+    console.log(chalk.gray(`    ${example.desc}\n`));
+  }
+
+  console.log(chalk.blue('  ───────────────────────────────────────────────────────────\n'));
+
+  console.log(chalk.white('  Pro Tips:\n'));
+  console.log(chalk.gray('  • Ask the AI ') + chalk.cyan('"What patterns do you have for payments?"'));
+  console.log(chalk.gray('  • Say ') + chalk.cyan('"/build a SaaS app"') + chalk.gray(' to start a full project'));
+  console.log(chalk.gray('  • Try ') + chalk.cyan('"/audit"') + chalk.gray(' to check code quality'));
+  console.log(chalk.gray('  • Use ') + chalk.cyan('"codebakers doctor"') + chalk.gray(' if something seems wrong\n'));
+
+  console.log(chalk.blue('  ═══════════════════════════════════════════════════════════\n'));
+}
+
+/**
+ * Format user-friendly error with context and recovery steps
+ */
+export interface FriendlyError {
+  title: string;
+  message: string;
+  cause?: string;
+  recovery: string[];
+  helpUrl?: string;
+}
+
+export function formatFriendlyError(error: FriendlyError): string {
+  let output = '';
+
+  output += chalk.red(`\n  ❌ ${error.title}\n`);
+  output += chalk.white(`\n  ${error.message}\n`);
+
+  if (error.cause) {
+    output += chalk.gray(`\n  Why: ${error.cause}\n`);
+  }
+
+  if (error.recovery.length > 0) {
+    output += chalk.yellow(`\n  How to fix:\n`);
+    for (let i = 0; i < error.recovery.length; i++) {
+      output += chalk.white(`    ${i + 1}. ${error.recovery[i]}\n`);
+    }
+  }
+
+  if (error.helpUrl) {
+    output += chalk.gray(`\n  More help: ${error.helpUrl}\n`);
+  }
+
+  return output;
+}
+
+/**
+ * Common error handlers with friendly messages
+ */
+export function getNetworkError(): FriendlyError {
+  return {
+    title: 'Connection Failed',
+    message: 'Could not connect to CodeBakers servers.',
+    cause: 'This usually means a network issue or the server is temporarily unavailable.',
+    recovery: [
+      'Check your internet connection',
+      'Try again in a few seconds',
+      'If using a VPN, try disabling it temporarily',
+      'Check status.codebakers.ai for server status',
+    ],
+    helpUrl: 'https://codebakers.ai/docs/troubleshooting',
+  };
+}
+
+export function getAuthError(): FriendlyError {
+  return {
+    title: 'Authentication Failed',
+    message: 'Your API key is invalid or expired.',
+    recovery: [
+      'Go to codebakers.ai/dashboard',
+      'Copy your API key (starts with cb_)',
+      'Run: codebakers setup',
+    ],
+    helpUrl: 'https://codebakers.ai/docs/getting-started',
+  };
+}
+
+export function getSubscriptionError(): FriendlyError {
+  return {
+    title: 'Subscription Required',
+    message: 'This feature requires an active subscription.',
+    recovery: [
+      'Visit codebakers.ai/pricing to see plans',
+      'Start a free trial with: codebakers setup',
+      'Contact support if you believe this is an error',
+    ],
+    helpUrl: 'https://codebakers.ai/pricing',
+  };
+}