codebakers 1.0.45 → 2.0.0

package/src/commands/init.ts

@@ -0,0 +1,574 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { execa } from 'execa';
+import { Config } from '../utils/config.js';
+import { GitHubService } from '../services/github.js';
+import { VercelService } from '../services/vercel.js';
+import { SupabaseService } from '../services/supabase.js';
+import { generateClaudeMd } from '../utils/claude-md.js';
+
+interface InitOptions {
+  name?: string;
+  template?: string;
+  git?: boolean;
+  vercel?: boolean;
+  supabase?: boolean;
+}
+
+export async function initCommand(options: InitOptions = {}): Promise<void> {
+  const config = new Config();
+
+  // Check if configured
+  if (!config.isConfigured()) {
+    p.log.error('Please run `codebakers setup` first.');
+    return;
+  }
+
+  p.intro(chalk.bgCyan.black(' Create New Project '));
+
+  // Project name
+  let projectName = options.name;
+  if (!projectName) {
+    const name = await p.text({
+      message: 'Project name:',
+      placeholder: 'my-app',
+      validate: (value) => {
+        if (!value) return 'Project name is required';
+        if (!/^[a-z0-9-]+$/.test(value)) return 'Use lowercase letters, numbers, and hyphens only';
+        return undefined;
+      },
+    });
+    if (p.isCancel(name)) return;
+    projectName = name as string;
+  }
+
+  // Project type
+  const projectType = await p.select({
+    message: 'What are you building?',
+    options: [
+      { value: 'web', label: '🌐 Web app', hint: 'Next.js → Vercel' },
+      { value: 'mobile', label: '📱 Mobile app', hint: 'Expo → App stores' },
+      { value: 'desktop', label: '🖥️  Desktop app', hint: 'Tauri → Windows/Mac/Linux' },
+      { value: 'fullstack', label: '📦 Full stack', hint: 'Web + Mobile + Desktop' },
+    ],
+  });
+  if (p.isCancel(projectType)) return;
+
+  // Framework selection (for web)
+  let framework = 'nextjs';
+  if (projectType === 'web' || projectType === 'fullstack') {
+    const selected = await p.select({
+      message: 'Framework:',
+      options: [
+        { value: 'nextjs', label: 'Next.js 14+', hint: config.getPreference('defaultFramework') === 'nextjs' ? '(your usual choice)' : '' },
+        { value: 'remix', label: 'Remix' },
+        { value: 'vite', label: 'Vite + React' },
+        { value: 'astro', label: 'Astro' },
+      ],
+    });
+    if (p.isCancel(selected)) return;
+    framework = selected as string;
+    config.learnPreference('defaultFramework', framework);
+  }
+
+  // UI Library
+  const uiLibrary = await p.select({
+    message: 'UI Library:',
+    options: [
+      { value: 'shadcn', label: 'shadcn/ui', hint: config.getPreference('defaultUI') === 'shadcn' ? '(your usual choice)' : 'Recommended' },
+      { value: 'chakra', label: 'Chakra UI' },
+      { value: 'mantine', label: 'Mantine' },
+      { value: 'mui', label: 'Material UI' },
+      { value: 'headless', label: 'Headless UI' },
+      { value: 'tailwind', label: 'Tailwind only' },
+    ],
+  });
+  if (p.isCancel(uiLibrary)) return;
+  config.learnPreference('defaultUI', uiLibrary);
+
+  // Packages
+  const packages = await p.multiselect({
+    message: 'Additional packages:',
+    options: [
+      { value: 'typescript', label: 'TypeScript', hint: 'Always recommended' },
+      { value: 'tailwind', label: 'Tailwind CSS' },
+      { value: 'zod', label: 'Zod', hint: 'Validation' },
+      { value: 'tanstack-query', label: 'TanStack Query', hint: 'Data fetching' },
+      { value: 'zustand', label: 'Zustand', hint: 'State management' },
+      { value: 'react-hook-form', label: 'React Hook Form' },
+      { value: 'lucide', label: 'Lucide Icons' },
+      { value: 'trpc', label: 'tRPC' },
+    ],
+    initialValues: ['typescript', 'tailwind', 'zod', 'zustand', 'lucide'],
+  });
+  if (p.isCancel(packages)) return;
+
+  // Services to provision
+  const services = await p.multiselect({
+    message: 'Services to provision:',
+    options: [
+      { value: 'github', label: 'GitHub', hint: 'Repository' },
+      { value: 'vercel', label: 'Vercel', hint: 'Hosting' },
+      { value: 'supabase', label: 'Supabase', hint: 'Database + Auth' },
+      { value: 'stripe', label: 'Stripe', hint: 'Payments' },
+      { value: 'resend', label: 'Resend', hint: 'Email' },
+      { value: 'vapi', label: 'VAPI', hint: 'Voice AI' },
+    ],
+    initialValues: ['github', 'vercel', 'supabase'],
+  });
+  if (p.isCancel(services)) return;
+
+  // Domain
+  let domain: string | undefined;
+  const domainChoice = await p.select({
+    message: 'Domain:',
+    options: [
+      { value: 'subdomain', label: 'Subdomain', hint: `${projectName}.yourdomain.com` },
+      { value: 'vercel', label: 'Vercel subdomain', hint: `${projectName}.vercel.app` },
+      { value: 'purchase', label: 'Purchase new domain' },
+      { value: 'skip', label: 'Skip for now' },
+    ],
+  });
+  if (p.isCancel(domainChoice)) return;
+
+  if (domainChoice === 'subdomain') {
+    const sub = await p.text({
+      message: 'Subdomain:',
+      placeholder: projectName,
+      initialValue: projectName,
+    });
+    if (!p.isCancel(sub)) {
+      domain = `${sub}.yourdomain.com`;
+    }
+  }
+
+  // Confirm
+  const projectConfig = {
+    name: projectName,
+    type: projectType,
+    framework,
+    ui: uiLibrary,
+    packages,
+    services,
+    domain,
+  };
+
+  p.note(
+    `Name:       ${projectName}
+Type:       ${projectType}
+Framework:  ${framework}
+UI:         ${uiLibrary}
+Packages:   ${(packages as string[]).join(', ')}
+Services:   ${(services as string[]).join(', ')}
+Domain:     ${domain || 'Vercel default'}`,
+    'Configuration'
+  );
+
+  const confirmed = await p.confirm({
+    message: 'Create project?',
+    initialValue: true,
+  });
+
+  if (!confirmed || p.isCancel(confirmed)) {
+    p.cancel('Project creation cancelled.');
+    return;
+  }
+
+  // Create project
+  const spinner = p.spinner();
+  const projectPath = path.join(process.cwd(), projectName);
+
+  try {
+    // Step 1: Create local project
+    spinner.start('Creating local project...');
+    await createLocalProject(projectPath, projectConfig);
+    spinner.stop('Local project created');
+
+    // Step 2: Install dependencies
+    spinner.start('Installing dependencies...');
+    await execa('pnpm', ['install'], { cwd: projectPath });
+    spinner.stop('Dependencies installed');
+
+    // Step 3: GitHub
+    if ((services as string[]).includes('github')) {
+      spinner.start('Creating GitHub repository...');
+      const github = new GitHubService(config);
+      const repo = await github.createRepo(projectName, { private: true });
+      spinner.stop(`GitHub repo created: ${repo.html_url}`);
+
+      // Init git and push
+      await execa('git', ['init'], { cwd: projectPath });
+      await execa('git', ['add', '.'], { cwd: projectPath });
+      await execa('git', ['commit', '-m', 'Initial commit by CodeBakers'], { cwd: projectPath });
+      await execa('git', ['remote', 'add', 'origin', repo.clone_url], { cwd: projectPath });
+      await execa('git', ['push', '-u', 'origin', 'main'], { cwd: projectPath });
+    }
+
+    // Step 4: Supabase
+    if ((services as string[]).includes('supabase')) {
+      spinner.start('Creating Supabase project...');
+      const supabase = new SupabaseService(config);
+      const project = await supabase.createProject(projectName);
+      spinner.stop(`Supabase project created: ${project.name}`);
+
+      // Save Supabase config
+      await fs.writeJson(
+        path.join(projectPath, '.codebakers', 'supabase.json'),
+        { projectId: project.id, projectUrl: project.api_url },
+        { spaces: 2 }
+      );
+    }
+
+    // Step 5: Vercel
+    if ((services as string[]).includes('vercel')) {
+      spinner.start('Creating Vercel project...');
+      const vercel = new VercelService(config);
+      const project = await vercel.createProject(projectName);
+      spinner.stop(`Vercel project created`);
+
+      // Configure domain if specified
+      if (domain) {
+        spinner.start(`Configuring domain: ${domain}...`);
+        await vercel.addDomain(projectName, domain);
+        spinner.stop('Domain configured');
+      }
+
+      // Deploy
+      spinner.start('Deploying to Vercel...');
+      const deployment = await vercel.deploy(projectPath);
+      spinner.stop(`Deployed: ${deployment.url}`);
+    }
+
+    // Step 6: Generate CLAUDE.md
+    spinner.start('Generating CLAUDE.md...');
+    const claudeMd = generateClaudeMd(projectConfig);
+    await fs.writeFile(path.join(projectPath, 'CLAUDE.md'), claudeMd);
+    spinner.stop('CLAUDE.md generated');
+
+    // Step 7: Setup git hooks
+    spinner.start('Setting up CodeBakers enforcement...');
+    await setupGitHooks(projectPath);
+    spinner.stop('CodeBakers enforcement configured');
+
+    // Save project to config
+    config.addProject({
+      name: projectName,
+      path: projectPath,
+      createdAt: new Date().toISOString(),
+    });
+
+    // Success!
+    p.outro(chalk.green(`
+✓ Project created!
+
+${chalk.bold('Your project is ready:')}
+  ${chalk.cyan(`cd ${projectName}`)}
+  ${chalk.cyan('codebakers code')}
+
+${chalk.dim('Shortcuts:')}
+  ${chalk.cyan('codebakers')} — Interactive menu
+  ${chalk.cyan('codebakers code')} — AI coding agent
+  ${chalk.cyan('codebakers check')} — Pattern enforcement
+  ${chalk.cyan('codebakers deploy')} — Deploy to production
+`));
+
+  } catch (error) {
+    spinner.stop('Error occurred');
+    p.log.error(`Failed to create project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    
+    // Offer to clean up
+    const cleanup = await p.confirm({
+      message: 'Clean up partially created project?',
+    });
+    
+    if (cleanup && !p.isCancel(cleanup)) {
+      await fs.remove(projectPath);
+      p.log.info('Cleaned up.');
+    }
+  }
+}
+
+async function createLocalProject(
+  projectPath: string,
+  config: Record<string, unknown>
+): Promise<void> {
+  const framework = config.framework as string;
+  const ui = config.ui as string;
+  const packages = config.packages as string[];
+
+  // Create directory structure
+  await fs.ensureDir(projectPath);
+  await fs.ensureDir(path.join(projectPath, '.codebakers'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'app'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'components', 'ui'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'components', 'features'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'lib'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'hooks'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'types'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'stores'));
+  await fs.ensureDir(path.join(projectPath, 'src', 'services'));
+
+  // Create package.json
+  const packageJson = {
+    name: path.basename(projectPath),
+    version: '0.1.0',
+    private: true,
+    scripts: {
+      dev: 'next dev',
+      build: 'next build',
+      start: 'next start',
+      lint: 'next lint',
+      typecheck: 'tsc --noEmit',
+      'codebakers:check': 'codebakers check',
+    },
+    dependencies: {
+      next: '^14.2.0',
+      react: '^18.3.0',
+      'react-dom': '^18.3.0',
+    },
+    devDependencies: {
+      typescript: '^5.5.0',
+      '@types/node': '^22.0.0',
+      '@types/react': '^18.3.0',
+      '@types/react-dom': '^18.3.0',
+    },
+  };
+
+  // Add packages based on selection
+  if (packages.includes('tailwind')) {
+    packageJson.devDependencies['tailwindcss'] = '^3.4.0';
+    packageJson.devDependencies['postcss'] = '^8.4.0';
+    packageJson.devDependencies['autoprefixer'] = '^10.4.0';
+  }
+  if (packages.includes('zod')) {
+    packageJson.dependencies['zod'] = '^3.23.0';
+  }
+  if (packages.includes('zustand')) {
+    packageJson.dependencies['zustand'] = '^4.5.0';
+  }
+  if (packages.includes('tanstack-query')) {
+    packageJson.dependencies['@tanstack/react-query'] = '^5.50.0';
+  }
+  if (packages.includes('react-hook-form')) {
+    packageJson.dependencies['react-hook-form'] = '^7.52.0';
+    packageJson.dependencies['@hookform/resolvers'] = '^3.9.0';
+  }
+  if (packages.includes('lucide')) {
+    packageJson.dependencies['lucide-react'] = '^0.400.0';
+  }
+  if (ui === 'shadcn') {
+    packageJson.dependencies['class-variance-authority'] = '^0.7.0';
+    packageJson.dependencies['clsx'] = '^2.1.0';
+    packageJson.dependencies['tailwind-merge'] = '^2.4.0';
+    packageJson.dependencies['sonner'] = '^1.5.0';
+  }
+
+  // Add Supabase
+  packageJson.dependencies['@supabase/supabase-js'] = '^2.45.0';
+  packageJson.dependencies['@supabase/ssr'] = '^0.4.0';
+
+  await fs.writeJson(path.join(projectPath, 'package.json'), packageJson, { spaces: 2 });
+
+  // Create other config files
+  await createConfigFiles(projectPath, config);
+
+  // Create CodeBakers project config
+  await fs.writeJson(
+    path.join(projectPath, '.codebakers', 'config.json'),
+    {
+      version: '1.0.0',
+      framework,
+      ui,
+      packages,
+      patterns: ['00-core', '01-database', '02-auth', '03-api', '04-frontend'],
+      createdAt: new Date().toISOString(),
+    },
+    { spaces: 2 }
+  );
+}
+
+async function createConfigFiles(
+  projectPath: string,
+  config: Record<string, unknown>
+): Promise<void> {
+  // TypeScript config
+  const tsConfig = {
+    compilerOptions: {
+      target: 'ES2022',
+      lib: ['dom', 'dom.iterable', 'ES2022'],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: 'esnext',
+      moduleResolution: 'bundler',
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: 'preserve',
+      incremental: true,
+      plugins: [{ name: 'next' }],
+      paths: { '@/*': ['./src/*'] },
+    },
+    include: ['next-env.d.ts', '**/*.ts', '**/*.tsx', '.next/types/**/*.ts'],
+    exclude: ['node_modules'],
+  };
+  await fs.writeJson(path.join(projectPath, 'tsconfig.json'), tsConfig, { spaces: 2 });
+
+  // Next.js config
+  const nextConfig = `/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    typedRoutes: true,
+  },
+};
+
+export default nextConfig;
+`;
+  await fs.writeFile(path.join(projectPath, 'next.config.mjs'), nextConfig);
+
+  // Tailwind config
+  const tailwindConfig = `import type { Config } from 'tailwindcss';
+
+const config: Config = {
+  darkMode: ['class'],
+  content: [
+    './src/pages/**/*.{js,ts,jsx,tsx,mdx}',
+    './src/components/**/*.{js,ts,jsx,tsx,mdx}',
+    './src/app/**/*.{js,ts,jsx,tsx,mdx}',
+  ],
+  theme: {
+    extend: {
+      colors: {
+        border: 'hsl(var(--border))',
+        input: 'hsl(var(--input))',
+        ring: 'hsl(var(--ring))',
+        background: 'hsl(var(--background))',
+        foreground: 'hsl(var(--foreground))',
+        primary: {
+          DEFAULT: 'hsl(var(--primary))',
+          foreground: 'hsl(var(--primary-foreground))',
+        },
+        secondary: {
+          DEFAULT: 'hsl(var(--secondary))',
+          foreground: 'hsl(var(--secondary-foreground))',
+        },
+        destructive: {
+          DEFAULT: 'hsl(var(--destructive))',
+          foreground: 'hsl(var(--destructive-foreground))',
+        },
+        muted: {
+          DEFAULT: 'hsl(var(--muted))',
+          foreground: 'hsl(var(--muted-foreground))',
+        },
+        accent: {
+          DEFAULT: 'hsl(var(--accent))',
+          foreground: 'hsl(var(--accent-foreground))',
+        },
+      },
+      borderRadius: {
+        lg: 'var(--radius)',
+        md: 'calc(var(--radius) - 2px)',
+        sm: 'calc(var(--radius) - 4px)',
+      },
+    },
+  },
+  plugins: [require('tailwindcss-animate')],
+};
+
+export default config;
+`;
+  await fs.writeFile(path.join(projectPath, 'tailwind.config.ts'), tailwindConfig);
+
+  // .env.example
+  const envExample = `# Supabase
+NEXT_PUBLIC_SUPABASE_URL=
+NEXT_PUBLIC_SUPABASE_ANON_KEY=
+SUPABASE_SERVICE_ROLE_KEY=
+
+# Stripe (optional)
+STRIPE_SECRET_KEY=
+NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=
+STRIPE_WEBHOOK_SECRET=
+
+# App
+NEXT_PUBLIC_APP_URL=http://localhost:3000
+`;
+  await fs.writeFile(path.join(projectPath, '.env.example'), envExample);
+  await fs.writeFile(path.join(projectPath, '.env.local'), envExample);
+
+  // .gitignore
+  const gitignore = `# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Build
+.next/
+out/
+build/
+dist/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Testing
+coverage/
+.nyc_output/
+
+# Misc
+*.pem
+`;
+  await fs.writeFile(path.join(projectPath, '.gitignore'), gitignore);
+}
+
+async function setupGitHooks(projectPath: string): Promise<void> {
+  // Create pre-commit hook
+  const hooksDir = path.join(projectPath, '.git', 'hooks');
+  
+  // Check if git is initialized
+  if (!await fs.pathExists(path.join(projectPath, '.git'))) {
+    await execa('git', ['init'], { cwd: projectPath });
+  }
+
+  await fs.ensureDir(hooksDir);
+
+  const preCommitHook = `#!/bin/sh
+# CodeBakers pre-commit hook
+
+echo "🔍 Running CodeBakers check..."
+
+# Run pattern check
+codebakers check
+
+# If check fails, abort commit
+if [ $? -ne 0 ]; then
+  echo "❌ CodeBakers check failed. Fix issues or use --no-verify to bypass."
+  exit 1
+fi
+
+echo "✓ CodeBakers check passed"
+`;
+
+  await fs.writeFile(path.join(hooksDir, 'pre-commit'), preCommitHook);
+  await fs.chmod(path.join(hooksDir, 'pre-commit'), '755');
+}

package/src/commands/learn.ts

@@ -0,0 +1,36 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { Config } from '../utils/config.js';
+
+export async function learnCommand(): Promise<void> {
+  const config = new Config();
+  const learning = config.getLearning();
+
+  p.intro(chalk.bgCyan.black(' Learning Settings '));
+
+  console.log(chalk.bold('\n🧠 What CodeBakers has learned about you:\n'));
+
+  const shortcuts = Object.entries(learning.shortcuts);
+  if (shortcuts.length > 0) {
+    console.log(chalk.bold('Shortcuts:'));
+    for (const [short, full] of shortcuts) {
+      console.log(`  ${chalk.cyan(short)} → ${full}`);
+    }
+    console.log('');
+  }
+
+  const prefs = Object.entries(learning.preferences);
+  if (prefs.length > 0) {
+    console.log(chalk.bold('Preferences:'));
+    for (const [key, value] of prefs) {
+      console.log(`  ${key}: ${chalk.cyan(String(value))}`);
+    }
+    console.log('');
+  }
+
+  if (shortcuts.length === 0 && prefs.length === 0) {
+    console.log(chalk.dim('  Nothing learned yet. Use CodeBakers more!\n'));
+  }
+
+  p.outro('');
+}

package/src/commands/security.ts

@@ -0,0 +1,102 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import glob from 'fast-glob';
+import * as path from 'path';
+
+export async function securityCommand(): Promise<void> {
+  p.intro(chalk.bgCyan.black(' Security Audit '));
+
+  const spinner = p.spinner();
+  spinner.start('Scanning for security issues...');
+
+  const issues = await runSecurityScan();
+
+  spinner.stop('Scan complete');
+
+  if (issues.length === 0) {
+    console.log(chalk.green('\n✓ No security issues found!\n'));
+    displaySecurityScore(100);
+  } else {
+    console.log(chalk.yellow(`\n⚠️  ${issues.length} security issues found:\n`));
+    
+    for (const issue of issues) {
+      const icon = issue.severity === 'critical' ? chalk.red('🔴') :
+                   issue.severity === 'high' ? chalk.red('🟠') :
+                   chalk.yellow('🟡');
+      
+      console.log(`${icon} ${chalk.bold(issue.title)}`);
+      console.log(chalk.dim(`   ${issue.file}:${issue.line}`));
+      console.log(`   ${issue.description}\n`);
+    }
+
+    const score = Math.max(0, 100 - 
+      (issues.filter(i => i.severity === 'critical').length * 30) -
+      (issues.filter(i => i.severity === 'high').length * 15));
+    displaySecurityScore(score);
+  }
+
+  p.outro('');
+}
+
+interface SecurityIssue {
+  title: string;
+  description: string;
+  file: string;
+  line: number;
+  severity: 'critical' | 'high' | 'medium';
+}
+
+async function runSecurityScan(): Promise<SecurityIssue[]> {
+  const cwd = process.cwd();
+  const issues: SecurityIssue[] = [];
+
+  const files = await glob(['src/**/*.{ts,tsx,js,jsx}'], { 
+    cwd,
+    ignore: ['**/node_modules/**'],
+  });
+
+  const patterns = [
+    {
+      pattern: /(sk_live_|sk_test_)[a-zA-Z0-9]+/g,
+      title: 'Hardcoded Stripe key',
+      severity: 'critical' as const,
+      description: 'Stripe API key should be in environment variables',
+    },
+    {
+      pattern: /\beval\s*\(/g,
+      title: 'Use of eval()',
+      severity: 'critical' as const,
+      description: 'eval() is a security vulnerability',
+    },
+    {
+      pattern: /dangerouslySetInnerHTML/g,
+      title: 'dangerouslySetInnerHTML',
+      severity: 'high' as const,
+      description: 'Ensure content is sanitized with DOMPurify',
+    },
+  ];
+
+  for (const file of files) {
+    const content = await fs.readFile(path.join(cwd, file), 'utf-8');
+
+    for (const { pattern, title, severity, description } of patterns) {
+      let match;
+      const regex = new RegExp(pattern.source, pattern.flags);
+      while ((match = regex.exec(content)) !== null) {
+        const line = content.substring(0, match.index).split('\n').length;
+        issues.push({ title, description, file, line, severity });
+      }
+    }
+  }
+
+  return issues;
+}
+
+function displaySecurityScore(score: number): void {
+  const color = score >= 80 ? chalk.green : score >= 50 ? chalk.yellow : chalk.red;
+  const grade = score >= 90 ? 'A' : score >= 80 ? 'B' : score >= 70 ? 'C' : 'F';
+  
+  console.log(chalk.bold('Security Score:'));
+  console.log(color(`\n  ${score}/100  Grade: ${grade}\n`));
+}