codebakers 1.0.45 → 2.0.1

package/src/index.ts

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
+import { Config } from './utils/config.js';
+import { checkForUpdates } from './utils/updates.js';
+import { setupCommand } from './commands/setup.js';
+import { initCommand } from './commands/init.js';
+import { codeCommand } from './commands/code.js';
+import { checkCommand } from './commands/check.js';
+import { deployCommand } from './commands/deploy.js';
+import { connectCommand } from './commands/connect.js';
+import { statusCommand } from './commands/status.js';
+import { gatewayCommand } from './commands/gateway.js';
+import { learnCommand } from './commands/learn.js';
+import { securityCommand } from './commands/security.js';
+import { generateCommand } from './commands/generate.js';
+import { fixCommand } from './commands/fix.js';
+import { designCommand } from './commands/design.js';
+
+const VERSION = '1.0.0';
+
+// ASCII art logo
+const logo = `
+   ██████╗ ██████╗ ██████╗ ███████╗██████╗  █████╗ ██╗  ██╗███████╗██████╗ ███████╗
+  ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗██╔══██╗██║ ██╔╝██╔════╝██╔══██╗██╔════╝
+  ██║     ██║   ██║██║  ██║█████╗  ██████╔╝███████║█████╔╝ █████╗  ██████╔╝███████╗
+  ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗██╔══██║██╔═██╗ ██╔══╝  ██╔══██╗╚════██║
+  ╚██████╗╚██████╔╝██████╔╝███████╗██████╔╝██║  ██║██║  ██╗███████╗██║  ██║███████║
+   ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚══════╝
+`;
+
+// Main interactive menu
+async function showMainMenu(): Promise<void> {
+  const config = new Config();
+  const isSetup = config.isConfigured();
+
+  // Show logo
+  console.log(gradient.pastel.multiline(logo));
+  console.log(chalk.dim(`  v${VERSION} — AI dev team that follows the rules\n`));
+
+  // If not setup, run setup wizard
+  if (!isSetup) {
+    console.log(boxen(
+      chalk.yellow('Welcome to CodeBakers! Let\'s get you set up.'),
+      { padding: 1, borderColor: 'yellow', borderStyle: 'round' }
+    ));
+    await setupCommand();
+    return;
+  }
+
+  // Check if in a project directory
+  const inProject = config.isInProject();
+
+  // Main menu
+  const action = await p.select({
+    message: 'What do you want to do?',
+    options: inProject ? [
+      { value: 'code', label: '💬 Code with AI', hint: 'build features, fix bugs' },
+      { value: 'check', label: '🔍 Check code quality', hint: 'run pattern enforcement' },
+      { value: 'deploy', label: '🚀 Deploy', hint: 'deploy to Vercel' },
+      { value: 'fix', label: '🔧 Fix errors', hint: 'auto-fix build/deploy errors' },
+      { value: 'generate', label: '⚡ Generate', hint: 'scaffold components, pages' },
+      { value: 'status', label: '📊 Project status', hint: 'view project health' },
+      { value: 'separator1', label: '─────────────────────────' },
+      { value: 'connect', label: '🔗 Connect service', hint: 'add integrations' },
+      { value: 'gateway', label: '📱 Channel gateway', hint: 'WhatsApp, Telegram, etc.' },
+      { value: 'learn', label: '🧠 Learning settings', hint: 'view what I\'ve learned' },
+      { value: 'security', label: '🔒 Security audit', hint: 'check for vulnerabilities' },
+      { value: 'design', label: '🎨 Design system', hint: 'set profile, colors' },
+      { value: 'separator2', label: '─────────────────────────' },
+      { value: 'new', label: '🆕 Create new project' },
+      { value: 'settings', label: '⚙️  Settings' },
+      { value: 'help', label: '❓ Help' },
+    ] : [
+      { value: 'new', label: '🆕 Create new project' },
+      { value: 'open', label: '📂 Open existing project' },
+      { value: 'status', label: '📊 View all projects' },
+      { value: 'separator1', label: '─────────────────────────' },
+      { value: 'connect', label: '🔗 Connect service' },
+      { value: 'gateway', label: '📱 Channel gateway', hint: 'WhatsApp, Telegram, etc.' },
+      { value: 'learn', label: '🧠 Learning settings' },
+      { value: 'settings', label: '⚙️  Settings' },
+      { value: 'help', label: '❓ Help' },
+    ]
+  });
+
+  if (p.isCancel(action)) {
+    p.cancel('Goodbye!');
+    process.exit(0);
+  }
+
+  // Handle actions
+  switch (action) {
+    case 'code':
+      await codeCommand();
+      break;
+    case 'check':
+      await checkCommand();
+      break;
+    case 'deploy':
+      await deployCommand();
+      break;
+    case 'fix':
+      await fixCommand();
+      break;
+    case 'generate':
+      await generateCommand();
+      break;
+    case 'status':
+      await statusCommand();
+      break;
+    case 'connect':
+      await connectCommand();
+      break;
+    case 'gateway':
+      await gatewayCommand();
+      break;
+    case 'learn':
+      await learnCommand();
+      break;
+    case 'security':
+      await securityCommand();
+      break;
+    case 'design':
+      await designCommand();
+      break;
+    case 'new':
+      await initCommand();
+      break;
+    case 'settings':
+      await setupCommand();
+      break;
+    case 'help':
+      showHelp();
+      break;
+    default:
+      // Separators, do nothing
+      await showMainMenu();
+  }
+}
+
+function showHelp(): void {
+  console.log(boxen(`
+${chalk.bold('CodeBakers CLI')} — AI dev team that follows the rules
+
+${chalk.bold('Commands:')}
+  ${chalk.cyan('codebakers')}              Interactive menu (or just run with no args)
+  ${chalk.cyan('codebakers init')}         Create a new project
+  ${chalk.cyan('codebakers code')}         Start AI coding session
+  ${chalk.cyan('codebakers check')}        Run pattern enforcement
+  ${chalk.cyan('codebakers deploy')}       Deploy to production
+  ${chalk.cyan('codebakers fix')}          Auto-fix errors
+  ${chalk.cyan('codebakers generate')}     Generate components/pages
+  ${chalk.cyan('codebakers connect')}      Connect external services
+  ${chalk.cyan('codebakers gateway')}      Manage messaging channels
+  ${chalk.cyan('codebakers status')}       View project status
+  ${chalk.cyan('codebakers security')}     Run security audit
+  ${chalk.cyan('codebakers learn')}        View/manage learning
+
+${chalk.bold('Help at any time:')}
+  Press ${chalk.yellow('?')} during any command to get contextual help
+
+${chalk.bold('Documentation:')}
+  ${chalk.dim('https://codebakers.dev/docs')}
+`, { padding: 1, borderColor: 'cyan', borderStyle: 'round' }));
+}
+
+// CLI setup with Commander
+const program = new Command();
+
+program
+  .name('codebakers')
+  .description('AI dev team that follows the rules')
+  .version(VERSION)
+  .action(showMainMenu);
+
+program
+  .command('setup')
+  .description('Configure CodeBakers (first-time setup)')
+  .action(setupCommand);
+
+program
+  .command('init')
+  .description('Create a new project')
+  .option('-n, --name <name>', 'Project name')
+  .option('-t, --template <template>', 'Template (nextjs, voice-agent, saas)')
+  .option('--no-git', 'Skip GitHub repo creation')
+  .option('--no-vercel', 'Skip Vercel deployment')
+  .option('--no-supabase', 'Skip Supabase setup')
+  .action(initCommand);
+
+program
+  .command('code [prompt]')
+  .description('Start AI coding session')
+  .option('-w, --watch', 'Watch mode - continuous assistance')
+  .action(codeCommand);
+
+program
+  .command('check')
+  .description('Run CodeBakers pattern enforcement')
+  .option('-f, --fix', 'Auto-fix violations')
+  .option('--watch', 'Watch mode')
+  .action(checkCommand);
+
+program
+  .command('deploy')
+  .description('Deploy to production')
+  .option('-p, --preview', 'Deploy to preview only')
+  .option('--no-check', 'Skip pattern check')
+  .action(deployCommand);
+
+program
+  .command('fix')
+  .description('Auto-fix build and deployment errors')
+  .option('--auto', 'Fix without asking')
+  .action(fixCommand);
+
+program
+  .command('generate <type>')
+  .alias('g')
+  .description('Generate components, pages, API routes')
+  .option('-n, --name <name>', 'Name of the generated item')
+  .action(generateCommand);
+
+program
+  .command('connect [service]')
+  .description('Connect external services (Stripe, VAPI, etc.)')
+  .action(connectCommand);
+
+program
+  .command('gateway')
+  .description('Manage messaging channel gateway')
+  .option('--start', 'Start the gateway')
+  .option('--stop', 'Stop the gateway')
+  .option('--status', 'Show gateway status')
+  .action(gatewayCommand);
+
+program
+  .command('status')
+  .description('View project status and health')
+  .option('-a, --all', 'Show all projects')
+  .action(statusCommand);
+
+program
+  .command('security')
+  .description('Run security audit')
+  .option('--fix', 'Auto-fix security issues')
+  .action(securityCommand);
+
+program
+  .command('learn')
+  .description('View and manage learning settings')
+  .option('--forget <item>', 'Forget a learned preference')
+  .option('--reset', 'Reset all learning')
+  .option('--export', 'Export learned patterns')
+  .action(learnCommand);
+
+program
+  .command('design [action]')
+  .description('Manage design system (profile, palette, check)')
+  .action(designCommand);
+
+// Parse args or show menu
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  // Check for updates in background
+  checkForUpdates().catch(() => {});
+  
+  // Show interactive menu
+  showMainMenu().catch(console.error);
+} else {
+  program.parse();
+}

package/src/patterns/loader.ts

@@ -0,0 +1,337 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { Config } from '../utils/config.js';
+
+// Embedded core patterns (extracted from your CLAUDE.md)
+const CORE_PATTERNS = `
+# CODEBAKERS CORE PATTERNS
+
+## ABSOLUTE PROHIBITIONS
+
+These will NEVER appear in your code:
+
+\`\`\`typescript
+// ❌ BANNED - NON-FUNCTIONAL CODE
+onClick={handleClick}       // where handleClick doesn't exist
+onSubmit={handleSubmit}     // where handleSubmit doesn't exist  
+href="/some-page"           // where the page doesn't exist
+
+// ❌ BANNED - INCOMPLETE CODE
+TODO:                       // No TODOs ever
+FIXME:                      // No FIXMEs ever
+// ...                      // No placeholder comments
+throw new Error('Not implemented')
+
+// ❌ BANNED - DEBUG CODE
+console.log('test')         // No debug logs
+debugger;                   // No debugger statements
+
+// ❌ BANNED - TYPE SAFETY VIOLATIONS
+any                         // No 'any' types
+@ts-ignore                  // No ignoring TypeScript
+as any                      // No casting to any
+
+// ❌ BANNED - SECURITY VIOLATIONS
+eval()                      // No eval ever
+innerHTML =                 // No direct innerHTML
+dangerouslySetInnerHTML     // Without DOMPurify
+\`\`\`
+
+## MANDATORY PATTERNS
+
+### Every Button MUST Have:
+
+\`\`\`typescript
+<Button 
+  onClick={handleAction}
+  disabled={isLoading || isDisabled}
+  aria-label="Descriptive action name"
+>
+  {isLoading ? (
+    <>
+      <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+      Processing...
+    </>
+  ) : (
+    'Action Name'
+  )}
+</Button>
+
+// The handler MUST exist and be complete:
+const handleAction = async () => {
+  setIsLoading(true);
+  try {
+    await performAction();
+    toast.success('Action completed successfully');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Action failed';
+    toast.error(message);
+  } finally {
+    setIsLoading(false);
+  }
+};
+\`\`\`
+
+### Every Form MUST Have:
+
+1. React Hook Form with Zod validation
+2. Loading state during submission
+3. Error messages for each field
+4. Success/error toast notifications
+5. Proper disabled state while submitting
+
+### Every Async Operation MUST Have:
+
+\`\`\`typescript
+const [data, setData] = useState<DataType | null>(null);
+const [isLoading, setIsLoading] = useState(false);
+const [error, setError] = useState<string | null>(null);
+
+const fetchData = async () => {
+  setIsLoading(true);
+  setError(null);
+  
+  try {
+    const response = await fetch('/api/data');
+    if (!response.ok) throw new Error(\`HTTP \${response.status}\`);
+    const result = await response.json();
+    setData(result.data);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to fetch';
+    setError(message);
+    toast.error(message);
+  } finally {
+    setIsLoading(false);
+  }
+};
+\`\`\`
+
+### Every List MUST Have:
+
+1. Loading state with spinner/skeleton
+2. Error state with retry button
+3. Empty state with helpful message
+4. Success state with data
+
+## FILE STRUCTURE
+
+\`\`\`
+src/
+├── app/                    # Next.js App Router
+│   ├── (auth)/            # Routes requiring authentication
+│   ├── (public)/          # Public routes
+│   ├── (marketing)/       # Marketing pages
+│   ├── api/               # API routes
+│   └── layout.tsx         # Root layout
+├── components/
+│   ├── ui/                # shadcn/ui components
+│   ├── forms/             # Form components
+│   ├── layouts/           # Layout components
+│   └── [feature]/         # Feature-specific components
+├── lib/
+│   ├── supabase/          # Supabase clients
+│   ├── utils.ts           # Utility functions
+│   └── validations.ts     # Zod schemas
+├── hooks/                  # Custom React hooks
+├── types/                  # TypeScript types
+├── stores/                 # Zustand stores
+└── services/              # Business logic
+\`\`\`
+
+## API ROUTE PATTERN
+
+\`\`\`typescript
+import { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+import { createServerClient } from '@/lib/supabase/server';
+
+const requestSchema = z.object({
+  // Define request body schema
+});
+
+export async function POST(request: NextRequest) {
+  try {
+    // 1. Auth check
+    const supabase = createServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    
+    if (authError || !user) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      );
+    }
+
+    // 2. Validate input
+    const body = await request.json();
+    const result = requestSchema.safeParse(body);
+    
+    if (!result.success) {
+      return NextResponse.json(
+        { error: 'Validation failed', details: result.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    // 3. Business logic
+    const data = result.data;
+    // ... do something
+
+    // 4. Return success
+    return NextResponse.json({ data }, { status: 201 });
+
+  } catch (error) {
+    console.error('[API] Error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+\`\`\`
+
+## SUPABASE RLS PATTERN
+
+Every table MUST have Row Level Security enabled:
+
+\`\`\`sql
+-- Enable RLS
+ALTER TABLE your_table ENABLE ROW LEVEL SECURITY;
+
+-- User can only see their own data
+CREATE POLICY "Users can view own data"
+  ON your_table FOR SELECT
+  TO authenticated
+  USING (user_id = auth.uid());
+
+-- User can only insert their own data  
+CREATE POLICY "Users can insert own data"
+  ON your_table FOR INSERT
+  TO authenticated
+  WITH CHECK (user_id = auth.uid());
+
+-- User can only update their own data
+CREATE POLICY "Users can update own data"
+  ON your_table FOR UPDATE
+  TO authenticated
+  USING (user_id = auth.uid())
+  WITH CHECK (user_id = auth.uid());
+
+-- User can only delete their own data
+CREATE POLICY "Users can delete own data"
+  ON your_table FOR DELETE
+  TO authenticated
+  USING (user_id = auth.uid());
+\`\`\`
+
+## STATE MANAGEMENT
+
+Use Zustand for global state:
+
+\`\`\`typescript
+import { create } from 'zustand';
+
+interface AppState {
+  user: User | null;
+  isLoading: boolean;
+  setUser: (user: User | null) => void;
+  reset: () => void;
+}
+
+export const useAppStore = create<AppState>((set) => ({
+  user: null,
+  isLoading: false,
+  setUser: (user) => set({ user }),
+  reset: () => set({ user: null, isLoading: false }),
+}));
+\`\`\`
+
+## ERROR HANDLING
+
+Use typed error classes:
+
+\`\`\`typescript
+export class AppError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public statusCode: number = 500
+  ) {
+    super(message);
+  }
+}
+
+export class AuthenticationError extends AppError {
+  constructor(message = 'Authentication required') {
+    super(message, 'AUTH_ERROR', 401);
+  }
+}
+
+export class ValidationError extends AppError {
+  constructor(message = 'Validation failed', public details?: Record<string, string[]>) {
+    super(message, 'VALIDATION_ERROR', 400);
+  }
+}
+\`\`\`
+`;
+
+export async function loadPatterns(config: Config): Promise<string> {
+  const projectDir = process.cwd();
+  const patterns: string[] = [CORE_PATTERNS];
+
+  // Load project-specific patterns if they exist
+  const projectPatternDir = path.join(projectDir, '.codebakers', 'patterns');
+  if (await fs.pathExists(projectPatternDir)) {
+    const files = await fs.readdir(projectPatternDir);
+    for (const file of files) {
+      if (file.endsWith('.md')) {
+        const content = await fs.readFile(path.join(projectPatternDir, file), 'utf-8');
+        patterns.push(content);
+      }
+    }
+  }
+
+  // Load global patterns
+  const globalPatternDir = config.getPatternsDir();
+  if (await fs.pathExists(globalPatternDir)) {
+    const files = await fs.readdir(globalPatternDir);
+    for (const file of files.slice(0, 10)) { // Limit to avoid context overflow
+      if (file.endsWith('.md')) {
+        const content = await fs.readFile(path.join(globalPatternDir, file), 'utf-8');
+        // Truncate if too long
+        patterns.push(content.slice(0, 10000));
+      }
+    }
+  }
+
+  return patterns.join('\n\n---\n\n');
+}
+
+export async function validateAgainstPatterns(
+  code: string,
+  patterns: string
+): Promise<{ valid: boolean; violations: string[] }> {
+  const violations: string[] = [];
+
+  // Check for banned patterns
+  if (code.includes(': any') && !code.includes('// @allow-any')) {
+    violations.push('Use of "any" type detected');
+  }
+  if (code.includes('@ts-ignore')) {
+    violations.push('@ts-ignore detected');
+  }
+  if (/console\.log\(/.test(code)) {
+    violations.push('console.log detected');
+  }
+  if (/TODO:|FIXME:/.test(code)) {
+    violations.push('TODO/FIXME comment detected');
+  }
+  if (/eval\s*\(/.test(code)) {
+    violations.push('eval() detected - security risk');
+  }
+
+  return {
+    valid: violations.length === 0,
+    violations,
+  };
+}

package/src/services/github.ts

@@ -0,0 +1,61 @@
+import { Octokit } from '@octokit/rest';
+import { Config } from '../utils/config.js';
+
+export class GitHubService {
+  private octokit: Octokit;
+  private config: Config;
+
+  constructor(config: Config) {
+    this.config = config;
+    const creds = config.getCredentials('github');
+    
+    if (!creds?.token) {
+      throw new Error('GitHub not configured. Run `codebakers setup`.');
+    }
+
+    this.octokit = new Octokit({ auth: creds.token });
+  }
+
+  async createRepo(name: string, options: { private?: boolean } = {}): Promise<{
+    id: number;
+    name: string;
+    full_name: string;
+    html_url: string;
+    clone_url: string;
+  }> {
+    const response = await this.octokit.repos.createForAuthenticatedUser({
+      name,
+      private: options.private ?? true,
+      auto_init: false,
+    });
+
+    return {
+      id: response.data.id,
+      name: response.data.name,
+      full_name: response.data.full_name,
+      html_url: response.data.html_url,
+      clone_url: response.data.clone_url,
+    };
+  }
+
+  async getUser(): Promise<{ login: string; name: string | null }> {
+    const response = await this.octokit.users.getAuthenticated();
+    return {
+      login: response.data.login,
+      name: response.data.name,
+    };
+  }
+
+  async listRepos(): Promise<Array<{ name: string; full_name: string; private: boolean }>> {
+    const response = await this.octokit.repos.listForAuthenticatedUser({
+      sort: 'updated',
+      per_page: 100,
+    });
+
+    return response.data.map(repo => ({
+      name: repo.name,
+      full_name: repo.full_name,
+      private: repo.private,
+    }));
+  }
+}