codebakers 1.0.45 → 2.0.1

package/src/commands/setup.ts

@@ -0,0 +1,448 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import open from 'open';
+import { Config } from '../utils/config.js';
+
+export async function setupCommand(): Promise<void> {
+  const config = new Config();
+
+  p.intro(chalk.bgCyan.black(' CodeBakers Setup '));
+
+  // Check if already configured
+  if (config.isConfigured()) {
+    const action = await p.select({
+      message: 'CodeBakers is already configured. What do you want to do?',
+      options: [
+        { value: 'view', label: '👀 View connected services' },
+        { value: 'add', label: '➕ Add another service' },
+        { value: 'update', label: '🔄 Update credentials' },
+        { value: 'reset', label: '🗑️  Reset all configuration' },
+        { value: 'back', label: '← Back' },
+      ],
+    });
+
+    if (p.isCancel(action) || action === 'back') {
+      return;
+    }
+
+    if (action === 'view') {
+      showConnectedServices(config);
+      return;
+    }
+
+    if (action === 'reset') {
+      const confirm = await p.confirm({
+        message: 'Are you sure? This will remove all credentials and settings.',
+      });
+      if (confirm) {
+        // Reset config - in real implementation would clear the config
+        p.outro(chalk.yellow('Configuration reset. Run `codebakers setup` again.'));
+      }
+      return;
+    }
+
+    if (action === 'add') {
+      await addService(config);
+      return;
+    }
+  }
+
+  // First-time setup
+  p.note(
+    `Let's connect your accounts. This only takes a few minutes.
+    
+${chalk.dim('Your credentials are stored locally in ~/.codebakers/')}
+${chalk.dim('and are never sent to our servers.')}`,
+    'Welcome to CodeBakers!'
+  );
+
+  // Required services
+  const requiredServices = [
+    { name: 'GitHub', key: 'github', required: true },
+    { name: 'Vercel', key: 'vercel', required: true },
+    { name: 'Supabase', key: 'supabase', required: true },
+    { name: 'Anthropic (Claude)', key: 'anthropic', required: true },
+  ];
+
+  // Optional services
+  const optionalServices = [
+    { name: 'OpenAI', key: 'openai' },
+    { name: 'Stripe', key: 'stripe' },
+    { name: 'Twilio', key: 'twilio' },
+    { name: 'VAPI', key: 'vapi' },
+    { name: 'Resend', key: 'resend' },
+    { name: 'ElevenLabs', key: 'elevenLabs' },
+    { name: 'Microsoft Graph', key: 'microsoft' },
+    { name: 'Google APIs', key: 'google' },
+  ];
+
+  p.log.step('Connecting required services...');
+
+  // Connect required services
+  for (const service of requiredServices) {
+    await connectService(config, service.key, service.name, true);
+  }
+
+  // Ask about optional services
+  const addOptional = await p.confirm({
+    message: 'Do you want to connect optional services? (Stripe, Twilio, etc.)',
+    initialValue: false,
+  });
+
+  if (addOptional && !p.isCancel(addOptional)) {
+    const selected = await p.multiselect({
+      message: 'Select services to connect:',
+      options: optionalServices.map(s => ({
+        value: s.key,
+        label: s.name,
+      })),
+      required: false,
+    });
+
+    if (!p.isCancel(selected)) {
+      for (const serviceKey of selected) {
+        const service = optionalServices.find(s => s.key === serviceKey);
+        if (service) {
+          await connectService(config, service.key, service.name, false);
+        }
+      }
+    }
+  }
+
+  // Copy patterns
+  p.log.step('Installing CodeBakers patterns...');
+  await installPatterns(config);
+
+  p.outro(chalk.green('✓ Setup complete! Run `codebakers init` to create your first project.'));
+}
+
+async function connectService(
+  config: Config,
+  serviceKey: string,
+  serviceName: string,
+  required: boolean
+): Promise<boolean> {
+  const spinner = p.spinner();
+
+  switch (serviceKey) {
+    case 'github': {
+      p.log.info(`${chalk.bold('GitHub')} - Opens browser for OAuth authorization`);
+      
+      const proceed = await p.confirm({
+        message: 'Open browser to authorize GitHub?',
+        initialValue: true,
+      });
+
+      if (p.isCancel(proceed) || !proceed) {
+        if (required) {
+          p.log.warn('GitHub is required. Skipping for now.');
+        }
+        return false;
+      }
+
+      // In real implementation, this would:
+      // 1. Start local server for OAuth callback
+      // 2. Open GitHub OAuth URL
+      // 3. Handle callback and save token
+      p.log.info(chalk.dim('Opening browser...'));
+      await open('https://github.com/login/oauth/authorize?client_id=YOUR_CLIENT_ID&scope=repo,user');
+
+      const token = await p.text({
+        message: 'Paste your GitHub token (or press Enter if OAuth completed):',
+        placeholder: 'ghp_...',
+      });
+
+      if (!p.isCancel(token) && token) {
+        config.setCredentials('github', { token: token as string });
+        p.log.success('GitHub connected!');
+        return true;
+      }
+      break;
+    }
+
+    case 'vercel': {
+      p.log.info(`${chalk.bold('Vercel')} - Opens browser for OAuth authorization`);
+      
+      const proceed = await p.confirm({
+        message: 'Open browser to authorize Vercel?',
+        initialValue: true,
+      });
+
+      if (p.isCancel(proceed) || !proceed) {
+        if (required) {
+          p.log.warn('Vercel is required. Skipping for now.');
+        }
+        return false;
+      }
+
+      p.log.info(chalk.dim('Opening browser...'));
+      await open('https://vercel.com/account/tokens');
+
+      const token = await p.text({
+        message: 'Paste your Vercel token:',
+        placeholder: 'vercel_...',
+      });
+
+      if (!p.isCancel(token) && token) {
+        config.setCredentials('vercel', { token: token as string });
+        p.log.success('Vercel connected!');
+        return true;
+      }
+      break;
+    }
+
+    case 'supabase': {
+      p.log.info(`${chalk.bold('Supabase')} - Opens browser for OAuth authorization`);
+      
+      const proceed = await p.confirm({
+        message: 'Open browser to authorize Supabase?',
+        initialValue: true,
+      });
+
+      if (p.isCancel(proceed) || !proceed) {
+        if (required) {
+          p.log.warn('Supabase is required. Skipping for now.');
+        }
+        return false;
+      }
+
+      p.log.info(chalk.dim('Opening browser...'));
+      await open('https://supabase.com/dashboard/account/tokens');
+
+      const token = await p.text({
+        message: 'Paste your Supabase access token:',
+        placeholder: 'sbp_...',
+      });
+
+      if (!p.isCancel(token) && token) {
+        config.setCredentials('supabase', { accessToken: token as string });
+        p.log.success('Supabase connected!');
+        return true;
+      }
+      break;
+    }
+
+    case 'anthropic': {
+      p.log.info(`${chalk.bold('Anthropic (Claude)')} - Powers the AI coding agent`);
+      
+      const openBrowser = await p.confirm({
+        message: 'Open browser to get API key?',
+        initialValue: true,
+      });
+
+      if (openBrowser && !p.isCancel(openBrowser)) {
+        await open('https://console.anthropic.com/settings/keys');
+      }
+
+      const apiKey = await p.text({
+        message: 'Paste your Anthropic API key:',
+        placeholder: 'sk-ant-...',
+        validate: (value) => {
+          if (!value && required) return 'API key is required';
+          if (value && !value.startsWith('sk-ant-')) return 'Invalid API key format';
+          return undefined;
+        },
+      });
+
+      if (!p.isCancel(apiKey) && apiKey) {
+        config.setCredentials('anthropic', { apiKey: apiKey as string });
+        p.log.success('Anthropic connected!');
+        return true;
+      }
+      break;
+    }
+
+    case 'openai': {
+      const openBrowser = await p.confirm({
+        message: 'Open browser to get OpenAI API key?',
+        initialValue: true,
+      });
+
+      if (openBrowser && !p.isCancel(openBrowser)) {
+        await open('https://platform.openai.com/api-keys');
+      }
+
+      const apiKey = await p.text({
+        message: 'Paste your OpenAI API key:',
+        placeholder: 'sk-...',
+      });
+
+      if (!p.isCancel(apiKey) && apiKey) {
+        config.setCredentials('openai', { apiKey: apiKey as string });
+        p.log.success('OpenAI connected!');
+        return true;
+      }
+      break;
+    }
+
+    case 'stripe': {
+      const openBrowser = await p.confirm({
+        message: 'Open browser to get Stripe API keys?',
+        initialValue: true,
+      });
+
+      if (openBrowser && !p.isCancel(openBrowser)) {
+        await open('https://dashboard.stripe.com/apikeys');
+      }
+
+      const secretKey = await p.text({
+        message: 'Paste your Stripe secret key:',
+        placeholder: 'sk_live_... or sk_test_...',
+      });
+
+      if (!p.isCancel(secretKey) && secretKey) {
+        config.setCredentials('stripe', { secretKey: secretKey as string });
+        p.log.success('Stripe connected!');
+        return true;
+      }
+      break;
+    }
+
+    case 'twilio': {
+      const openBrowser = await p.confirm({
+        message: 'Open browser to get Twilio credentials?',
+        initialValue: true,
+      });
+
+      if (openBrowser && !p.isCancel(openBrowser)) {
+        await open('https://console.twilio.com/');
+      }
+
+      const accountSid = await p.text({
+        message: 'Paste your Twilio Account SID:',
+        placeholder: 'AC...',
+      });
+
+      const authToken = await p.text({
+        message: 'Paste your Twilio Auth Token:',
+        placeholder: '...',
+      });
+
+      if (!p.isCancel(accountSid) && !p.isCancel(authToken) && accountSid && authToken) {
+        config.setCredentials('twilio', { 
+          accountSid: accountSid as string, 
+          authToken: authToken as string 
+        });
+        p.log.success('Twilio connected!');
+        return true;
+      }
+      break;
+    }
+
+    case 'vapi': {
+      const openBrowser = await p.confirm({
+        message: 'Open browser to get VAPI API key?',
+        initialValue: true,
+      });
+
+      if (openBrowser && !p.isCancel(openBrowser)) {
+        await open('https://dashboard.vapi.ai/');
+      }
+
+      const apiKey = await p.text({
+        message: 'Paste your VAPI API key:',
+        placeholder: '...',
+      });
+
+      if (!p.isCancel(apiKey) && apiKey) {
+        config.setCredentials('vapi', { apiKey: apiKey as string });
+        p.log.success('VAPI connected!');
+        return true;
+      }
+      break;
+    }
+
+    case 'resend': {
+      const openBrowser = await p.confirm({
+        message: 'Open browser to get Resend API key?',
+        initialValue: true,
+      });
+
+      if (openBrowser && !p.isCancel(openBrowser)) {
+        await open('https://resend.com/api-keys');
+      }
+
+      const apiKey = await p.text({
+        message: 'Paste your Resend API key:',
+        placeholder: 're_...',
+      });
+
+      if (!p.isCancel(apiKey) && apiKey) {
+        config.setCredentials('resend', { apiKey: apiKey as string });
+        p.log.success('Resend connected!');
+        return true;
+      }
+      break;
+    }
+
+    default:
+      p.log.warn(`Service ${serviceName} not yet implemented`);
+      return false;
+  }
+
+  return false;
+}
+
+async function addService(config: Config): Promise<void> {
+  const services = [
+    { value: 'github', label: 'GitHub' },
+    { value: 'vercel', label: 'Vercel' },
+    { value: 'supabase', label: 'Supabase' },
+    { value: 'anthropic', label: 'Anthropic (Claude)' },
+    { value: 'openai', label: 'OpenAI' },
+    { value: 'stripe', label: 'Stripe' },
+    { value: 'twilio', label: 'Twilio' },
+    { value: 'vapi', label: 'VAPI' },
+    { value: 'resend', label: 'Resend' },
+    { value: 'elevenLabs', label: 'ElevenLabs' },
+    { value: 'microsoft', label: 'Microsoft Graph' },
+    { value: 'google', label: 'Google APIs' },
+  ];
+
+  const service = await p.select({
+    message: 'Which service do you want to connect?',
+    options: services,
+  });
+
+  if (!p.isCancel(service)) {
+    const serviceInfo = services.find(s => s.value === service);
+    if (serviceInfo) {
+      await connectService(config, serviceInfo.value, serviceInfo.label, false);
+    }
+  }
+}
+
+function showConnectedServices(config: Config): void {
+  const services = [
+    { key: 'github', name: 'GitHub' },
+    { key: 'vercel', name: 'Vercel' },
+    { key: 'supabase', name: 'Supabase' },
+    { key: 'anthropic', name: 'Anthropic' },
+    { key: 'openai', name: 'OpenAI' },
+    { key: 'stripe', name: 'Stripe' },
+    { key: 'twilio', name: 'Twilio' },
+    { key: 'vapi', name: 'VAPI' },
+    { key: 'resend', name: 'Resend' },
+    { key: 'elevenLabs', name: 'ElevenLabs' },
+    { key: 'microsoft', name: 'Microsoft' },
+    { key: 'google', name: 'Google' },
+  ];
+
+  console.log('\n' + chalk.bold('Connected Services:') + '\n');
+
+  for (const service of services) {
+    const creds = config.getCredentials(service.key);
+    const isConnected = creds && Object.values(creds).some(v => v);
+    const status = isConnected ? chalk.green('✓ Connected') : chalk.dim('○ Not connected');
+    console.log(`  ${service.name.padEnd(15)} ${status}`);
+  }
+
+  console.log('');
+}
+
+async function installPatterns(config: Config): Promise<void> {
+  // In real implementation, this would copy the pattern files
+  // from the bundled templates to ~/.codebakers/patterns/
+  const patternsDir = config.getPatternsDir();
+  p.log.info(chalk.dim(`Patterns installed to ${patternsDir}`));
+}

package/src/commands/status.ts

@@ -0,0 +1,56 @@
+// src/commands/status.ts
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { Config } from '../utils/config.js';
+
+export async function statusCommand(): Promise<void> {
+  const config = new Config();
+  const cwd = process.cwd();
+
+  p.intro(chalk.bgCyan.black(' Project Status '));
+
+  if (!config.isInProject()) {
+    // Show all projects
+    const projects = config.getProjects();
+    
+    if (projects.length === 0) {
+      p.log.info('No projects found. Run `codebakers init` to create one.');
+      return;
+    }
+
+    console.log(chalk.bold('\nYour Projects:\n'));
+    
+    for (const project of projects) {
+      const exists = await fs.pathExists(project.path);
+      const status = exists ? chalk.green('✓') : chalk.red('✗');
+      console.log(`  ${status} ${project.name}`);
+      console.log(chalk.dim(`     ${project.path}`));
+      console.log('');
+    }
+    return;
+  }
+
+  // Show current project status
+  const projectConfig = await fs.readJson(
+    path.join(cwd, '.codebakers', 'config.json')
+  ).catch(() => ({}));
+
+  const packageJson = await fs.readJson(
+    path.join(cwd, 'package.json')
+  ).catch(() => ({}));
+
+  console.log(`
+${chalk.bold('Project:')} ${packageJson.name || path.basename(cwd)}
+${chalk.bold('Framework:')} ${projectConfig.framework || 'unknown'}
+${chalk.bold('UI:')} ${projectConfig.ui || 'unknown'}
+
+${chalk.bold('Quick Actions:')}
+  ${chalk.cyan('codebakers code')}   — AI coding agent
+  ${chalk.cyan('codebakers check')}  — Pattern enforcement  
+  ${chalk.cyan('codebakers deploy')} — Deploy to production
+`);
+
+  p.outro('');
+}