codebakers 1.0.45 → 2.0.0

package/src/services/supabase.ts

@@ -0,0 +1,147 @@
+import { Config } from '../utils/config.js';
+
+export class SupabaseService {
+  private config: Config;
+  private accessToken: string;
+
+  constructor(config: Config) {
+    this.config = config;
+    const creds = config.getCredentials('supabase');
+    
+    if (!creds?.accessToken) {
+      throw new Error('Supabase not configured. Run `codebakers setup`.');
+    }
+
+    this.accessToken = creds.accessToken;
+  }
+
+  async createProject(name: string): Promise<{
+    id: string;
+    name: string;
+    api_url: string;
+    anon_key: string;
+  }> {
+    // Generate a random password for the database
+    const dbPassword = this.generatePassword();
+
+    const response = await fetch('https://api.supabase.com/v1/projects', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name,
+        organization_id: await this.getDefaultOrgId(),
+        region: 'us-west-1',
+        plan: 'free',
+        db_pass: dbPassword,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || 'Failed to create Supabase project');
+    }
+
+    const data = await response.json();
+    
+    // Wait for project to be ready
+    await this.waitForProject(data.id);
+
+    // Get API keys
+    const keys = await this.getApiKeys(data.id);
+
+    return {
+      id: data.id,
+      name: data.name,
+      api_url: `https://${data.id}.supabase.co`,
+      anon_key: keys.anon_key,
+    };
+  }
+
+  private async getDefaultOrgId(): Promise<string> {
+    const response = await fetch('https://api.supabase.com/v1/organizations', {
+      headers: { Authorization: `Bearer ${this.accessToken}` },
+    });
+
+    if (!response.ok) {
+      throw new Error('Failed to get organizations');
+    }
+
+    const orgs = await response.json();
+    if (orgs.length === 0) {
+      throw new Error('No Supabase organization found');
+    }
+
+    return orgs[0].id;
+  }
+
+  private async waitForProject(projectId: string, maxWait = 120000): Promise<void> {
+    const startTime = Date.now();
+    
+    while (Date.now() - startTime < maxWait) {
+      const response = await fetch(
+        `https://api.supabase.com/v1/projects/${projectId}`,
+        { headers: { Authorization: `Bearer ${this.accessToken}` } }
+      );
+
+      if (response.ok) {
+        const project = await response.json();
+        if (project.status === 'ACTIVE_HEALTHY') {
+          return;
+        }
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 5000));
+    }
+
+    throw new Error('Timeout waiting for Supabase project');
+  }
+
+  private async getApiKeys(projectId: string): Promise<{ anon_key: string; service_role_key: string }> {
+    const response = await fetch(
+      `https://api.supabase.com/v1/projects/${projectId}/api-keys`,
+      { headers: { Authorization: `Bearer ${this.accessToken}` } }
+    );
+
+    if (!response.ok) {
+      throw new Error('Failed to get API keys');
+    }
+
+    const keys = await response.json();
+    const anonKey = keys.find((k: any) => k.name === 'anon');
+    const serviceKey = keys.find((k: any) => k.name === 'service_role');
+
+    return {
+      anon_key: anonKey?.api_key || '',
+      service_role_key: serviceKey?.api_key || '',
+    };
+  }
+
+  private generatePassword(): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%';
+    let password = '';
+    for (let i = 0; i < 24; i++) {
+      password += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return password;
+  }
+
+  async listProjects(): Promise<Array<{ id: string; name: string; region: string }>> {
+    const response = await fetch('https://api.supabase.com/v1/projects', {
+      headers: { Authorization: `Bearer ${this.accessToken}` },
+    });
+
+    if (!response.ok) {
+      throw new Error('Failed to list projects');
+    }
+
+    const projects = await response.json();
+    return projects.map((p: any) => ({
+      id: p.id,
+      name: p.name,
+      region: p.region,
+    }));
+  }
+}

package/src/services/vercel.ts

@@ -0,0 +1,61 @@
+import { execa } from 'execa';
+import { Config } from '../utils/config.js';
+
+export class VercelService {
+  private config: Config;
+  private token: string;
+
+  constructor(config: Config) {
+    this.config = config;
+    const creds = config.getCredentials('vercel');
+    
+    if (!creds?.token) {
+      throw new Error('Vercel not configured. Run `codebakers setup`.');
+    }
+
+    this.token = creds.token;
+  }
+
+  async createProject(name: string): Promise<{ id: string; name: string }> {
+    const response = await fetch('https://api.vercel.com/v9/projects', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ name, framework: 'nextjs' }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error?.message || 'Failed to create project');
+    }
+
+    const data = await response.json();
+    return { id: data.id, name: data.name };
+  }
+
+  async deploy(projectPath: string, production = false): Promise<{ url: string }> {
+    const args = ['vercel', '--yes'];
+    if (production) args.push('--prod');
+
+    const result = await execa('npx', args, {
+      cwd: projectPath,
+      env: { ...process.env, VERCEL_TOKEN: this.token },
+    });
+
+    const urlMatch = result.stdout.match(/https:\/\/[^\s]+\.vercel\.app/);
+    return { url: urlMatch ? urlMatch[0] : 'https://vercel.app' };
+  }
+
+  async addDomain(projectName: string, domain: string): Promise<void> {
+    await fetch(`https://api.vercel.com/v10/projects/${projectName}/domains`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ name: domain }),
+    });
+  }
+}

package/src/utils/claude-md.ts

@@ -0,0 +1,287 @@
+interface ProjectConfig {
+  name: string;
+  type: unknown;
+  framework: string;
+  ui: unknown;
+  packages: unknown;
+  services: unknown;
+  domain?: string;
+}
+
+export function generateClaudeMd(config: ProjectConfig): string {
+  return `# ${config.name.toUpperCase()} - CLAUDE.md
+
+Generated by CodeBakers CLI
+
+---
+
+# CORE DEVELOPMENT STANDARDS
+
+## 🧠 MANDATORY THINKING PROTOCOL
+
+**BEFORE WRITING ANY CODE**, complete this mental checklist:
+
+\`\`\`
+▢ What is the user actually asking for?
+▢ What are ALL the components needed (UI, API, DB, types)?
+▢ What are the edge cases?
+▢ What error handling is required?
+▢ What loading/empty states are needed?
+▢ How does this integrate with existing code?
+▢ What security implications exist?
+▢ What could break in production?
+\`\`\`
+
+**NEVER skip this step.**
+
+---
+
+## 🚫 ABSOLUTE PROHIBITIONS
+
+These will NEVER appear in your code under ANY circumstances:
+
+\`\`\`typescript
+// ❌ BANNED FOREVER - 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 FOREVER - INCOMPLETE CODE
+TODO:                        // No TODOs ever
+FIXME:                       // No FIXMEs ever
+// ...                       // No placeholder comments
+throw new Error('Not implemented')
+
+// ❌ BANNED FOREVER - DEBUG CODE
+console.log('test')          // No debug logs in final code
+debugger;                    // No debugger statements
+
+// ❌ BANNED FOREVER - TYPE SAFETY VIOLATIONS
+any                          // No 'any' types
+@ts-ignore                   // No ignoring TypeScript
+as any                       // No casting to any
+
+// ❌ BANNED FOREVER - SECURITY VIOLATIONS
+eval()                       // No eval ever
+innerHTML =                  // No direct innerHTML
+dangerouslySetInnerHTML      // Without DOMPurify
+\`\`\`
+
+---
+
+## ✅ MANDATORY PATTERNS
+
+### Every Button MUST Have:
+
+\`\`\`typescript
+// ✅ CORRECT - Fully functional button
+<Button 
+  onClick={handleAction}
+  disabled={isLoading || isDisabled}
+  aria-label="Descriptive action name"
+  aria-busy={isLoading}
+>
+  {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:
+
+\`\`\`typescript
+'use client';
+
+import { useState } from 'react';
+import { z } from 'zod';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { toast } from 'sonner';
+
+const formSchema = z.object({
+  email: z.string().email('Please enter a valid email'),
+  name: z.string().min(1, 'Name is required').max(100),
+});
+
+type FormData = z.infer<typeof formSchema>;
+
+export function ContactForm({ onSuccess }: { onSuccess?: () => void }) {
+  const [isSubmitting, setIsSubmitting] = useState(false);
+
+  const form = useForm<FormData>({
+    resolver: zodResolver(formSchema),
+    defaultValues: { email: '', name: '' },
+  });
+
+  const onSubmit = async (data: FormData) => {
+    setIsSubmitting(true);
+    try {
+      const response = await fetch('/api/contact', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || 'Failed to send');
+      }
+
+      toast.success('Message sent!');
+      form.reset();
+      onSuccess?.();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Something went wrong';
+      toast.error(message);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  return (
+    <Form {...form}>
+      <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
+        {/* Form fields with FormField, FormLabel, FormControl, FormMessage */}
+        <Button type="submit" disabled={isSubmitting}>
+          {isSubmitting ? 'Sending...' : 'Send Message'}
+        </Button>
+      </form>
+    </Form>
+  );
+}
+\`\`\`
+
+### Every List MUST Have:
+
+\`\`\`typescript
+interface ItemListProps {
+  items: Item[];
+  isLoading: boolean;
+  error: string | null;
+  onRetry?: () => void;
+}
+
+export function ItemList({ items, isLoading, error, onRetry }: ItemListProps) {
+  // Loading state
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center p-8">
+        <Loader2 className="h-8 w-8 animate-spin text-muted-foreground" />
+      </div>
+    );
+  }
+
+  // Error state
+  if (error) {
+    return (
+      <div className="flex flex-col items-center gap-4 p-8 text-center">
+        <AlertCircle className="h-12 w-12 text-destructive" />
+        <p className="text-destructive">{error}</p>
+        {onRetry && <Button variant="outline" onClick={onRetry}>Try Again</Button>}
+      </div>
+    );
+  }
+
+  // Empty state
+  if (items.length === 0) {
+    return (
+      <div className="flex flex-col items-center gap-4 p-8 text-center">
+        <Package className="h-12 w-12 text-muted-foreground" />
+        <div>
+          <h3 className="font-medium">No items found</h3>
+          <p className="text-sm text-muted-foreground">Get started by creating your first item.</p>
+        </div>
+      </div>
+    );
+  }
+
+  // Success state with data
+  return (
+    <ul className="divide-y divide-border">
+      {items.map((item) => (
+        <li key={item.id} className="p-4">
+          {item.name}
+        </li>
+      ))}
+    </ul>
+  );
+}
+\`\`\`
+
+---
+
+## 📁 PROJECT STRUCTURE
+
+\`\`\`
+${config.name}/
+├── src/
+│   ├── app/                    # Next.js App Router
+│   │   ├── (auth)/            # Routes requiring authentication
+│   │   ├── (public)/          # Public routes  
+│   │   ├── api/               # API routes
+│   │   └── layout.tsx         # Root layout
+│   ├── components/
+│   │   ├── ui/                # shadcn/ui components
+│   │   ├── forms/             # Form components
+│   │   └── [feature]/         # Feature-specific
+│   ├── lib/
+│   │   ├── supabase/          # Supabase clients
+│   │   ├── utils.ts           # Utilities
+│   │   └── validations.ts     # Zod schemas
+│   ├── hooks/                  # Custom hooks
+│   ├── types/                  # TypeScript types
+│   ├── stores/                 # Zustand stores
+│   └── services/              # Business logic
+├── tests/                      # Playwright tests
+├── .codebakers/               # CodeBakers config
+└── CLAUDE.md                  # This file
+\`\`\`
+
+---
+
+## 🔐 SECURITY REQUIREMENTS
+
+1. **Never expose secrets** - Use environment variables
+2. **Validate all inputs** - Use Zod on both client and server
+3. **Enable RLS** - Every Supabase table must have Row Level Security
+4. **Sanitize user content** - Use DOMPurify for any user HTML
+5. **Use HTTPS** - Never use HTTP in production
+6. **Rate limit APIs** - Protect public endpoints
+
+---
+
+## 🧪 TESTING REQUIREMENTS
+
+After building ANY feature, automatically test it:
+
+1. Run \`codebakers check\` to verify patterns
+2. Check TypeScript: \`npx tsc --noEmit\`
+3. Run tests: \`npm test\`
+4. Fix any failures before saying "done"
+
+---
+
+**END OF CLAUDE.md**
+
+Generated by CodeBakers CLI v1.0.0
+`;
+}