codebakers 1.0.45 → 2.0.1

package/dist/index.js

@@ -0,0 +1,4260 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import * as p13 from "@clack/prompts";
+import chalk14 from "chalk";
+import boxen from "boxen";
+import gradient from "gradient-string";
+
+// src/utils/config.ts
+import Conf from "conf";
+import * as fs from "fs-extra";
+import * as path from "path";
+import os from "os";
+import { z } from "zod";
+var ConfigSchema = z.object({
+  version: z.string().default("1.0.0"),
+  credentials: z.object({
+    github: z.object({
+      token: z.string().optional(),
+      username: z.string().optional()
+    }).optional(),
+    vercel: z.object({
+      token: z.string().optional(),
+      teamId: z.string().optional()
+    }).optional(),
+    supabase: z.object({
+      accessToken: z.string().optional(),
+      orgId: z.string().optional()
+    }).optional(),
+    anthropic: z.object({
+      apiKey: z.string().optional()
+    }).optional(),
+    openai: z.object({
+      apiKey: z.string().optional()
+    }).optional(),
+    stripe: z.object({
+      secretKey: z.string().optional(),
+      publishableKey: z.string().optional(),
+      webhookSecret: z.string().optional()
+    }).optional(),
+    twilio: z.object({
+      accountSid: z.string().optional(),
+      authToken: z.string().optional(),
+      phoneNumber: z.string().optional()
+    }).optional(),
+    vapi: z.object({
+      apiKey: z.string().optional()
+    }).optional(),
+    resend: z.object({
+      apiKey: z.string().optional()
+    }).optional(),
+    elevenLabs: z.object({
+      apiKey: z.string().optional()
+    }).optional(),
+    microsoft: z.object({
+      clientId: z.string().optional(),
+      clientSecret: z.string().optional(),
+      tenantId: z.string().optional()
+    }).optional(),
+    google: z.object({
+      clientId: z.string().optional(),
+      clientSecret: z.string().optional()
+    }).optional()
+  }).default({}),
+  preferences: z.object({
+    defaultFramework: z.string().optional(),
+    defaultUI: z.string().optional(),
+    defaultPackages: z.array(z.string()).optional(),
+    deployToPreviewFirst: z.boolean().default(true)
+  }).default({}),
+  learning: z.object({
+    enabled: z.boolean().default(true),
+    shortcuts: z.record(z.string()).default({}),
+    preferences: z.record(z.any()).default({}),
+    rejections: z.array(z.string()).default([]),
+    workflows: z.record(z.array(z.string())).default({})
+  }).default({}),
+  projects: z.array(z.object({
+    name: z.string(),
+    path: z.string(),
+    github: z.string().optional(),
+    vercel: z.string().optional(),
+    supabase: z.string().optional(),
+    createdAt: z.string()
+  })).default([]),
+  channels: z.object({
+    whatsapp: z.object({
+      enabled: z.boolean().default(false),
+      phoneNumber: z.string().optional()
+    }).optional(),
+    telegram: z.object({
+      enabled: z.boolean().default(false),
+      botToken: z.string().optional()
+    }).optional(),
+    discord: z.object({
+      enabled: z.boolean().default(false),
+      botToken: z.string().optional()
+    }).optional(),
+    slack: z.object({
+      enabled: z.boolean().default(false),
+      botToken: z.string().optional()
+    }).optional()
+  }).default({})
+});
+var Config = class {
+  conf;
+  configDir;
+  constructor() {
+    this.configDir = path.join(os.homedir(), ".codebakers");
+    fs.ensureDirSync(this.configDir);
+    fs.ensureDirSync(path.join(this.configDir, "patterns"));
+    fs.ensureDirSync(path.join(this.configDir, "templates"));
+    fs.ensureDirSync(path.join(this.configDir, "learning"));
+    this.conf = new Conf({
+      projectName: "codebakers",
+      cwd: this.configDir,
+      schema: {
+        version: { type: "string", default: "1.0.0" },
+        credentials: { type: "object", default: {} },
+        preferences: { type: "object", default: {} },
+        learning: { type: "object", default: { enabled: true, shortcuts: {}, preferences: {}, rejections: [], workflows: {} } },
+        projects: { type: "array", default: [] },
+        channels: { type: "object", default: {} }
+      }
+    });
+  }
+  // Check if initial setup is complete
+  isConfigured() {
+    const creds = this.conf.get("credentials") || {};
+    return !!(creds.github?.token && creds.vercel?.token && creds.supabase?.accessToken && creds.anthropic?.apiKey);
+  }
+  // Check if current directory is a CodeBakers project
+  isInProject() {
+    const cwd = process.cwd();
+    const codebakersDir = path.join(cwd, ".codebakers");
+    const claudeFile = path.join(cwd, "CLAUDE.md");
+    return fs.existsSync(codebakersDir) || fs.existsSync(claudeFile);
+  }
+  // Get current project config
+  getProjectConfig() {
+    const cwd = process.cwd();
+    const configPath = path.join(cwd, ".codebakers", "config.json");
+    if (fs.existsSync(configPath)) {
+      return fs.readJsonSync(configPath);
+    }
+    return null;
+  }
+  // Credentials
+  getCredentials(service) {
+    const creds = this.conf.get("credentials") || {};
+    return creds[service];
+  }
+  setCredentials(service, credentials) {
+    const current = this.conf.get("credentials") || {};
+    this.conf.set("credentials", {
+      ...current,
+      [service]: { ...current[service], ...credentials }
+    });
+  }
+  // Preferences
+  getPreference(key) {
+    const prefs = this.conf.get("preferences") || {};
+    return prefs[key];
+  }
+  setPreference(key, value) {
+    const current = this.conf.get("preferences") || {};
+    this.conf.set("preferences", { ...current, [key]: value });
+  }
+  // Learning
+  getLearning() {
+    return this.conf.get("learning") || { enabled: true, shortcuts: {}, preferences: {}, rejections: [], workflows: {} };
+  }
+  addShortcut(shortcut, expansion) {
+    const learning = this.getLearning();
+    learning.shortcuts[shortcut] = expansion;
+    this.conf.set("learning", learning);
+  }
+  addRejection(item) {
+    const learning = this.getLearning();
+    if (!learning.rejections.includes(item)) {
+      learning.rejections.push(item);
+      this.conf.set("learning", learning);
+    }
+  }
+  addWorkflow(name, steps) {
+    const learning = this.getLearning();
+    learning.workflows[name] = steps;
+    this.conf.set("learning", learning);
+  }
+  learnPreference(key, value) {
+    const learning = this.getLearning();
+    learning.preferences[key] = value;
+    this.conf.set("learning", learning);
+  }
+  forgetPreference(key) {
+    const learning = this.getLearning();
+    delete learning.preferences[key];
+    this.conf.set("learning", learning);
+  }
+  resetLearning() {
+    this.conf.set("learning", { enabled: true, shortcuts: {}, preferences: {}, rejections: [], workflows: {} });
+  }
+  // Projects
+  getProjects() {
+    return this.conf.get("projects") || [];
+  }
+  addProject(project) {
+    const projects = this.getProjects();
+    projects.push(project);
+    this.conf.set("projects", projects);
+  }
+  // Channels
+  getChannelConfig(channel) {
+    const channels = this.conf.get("channels") || {};
+    return channels[channel];
+  }
+  setChannelConfig(channel, config) {
+    const current = this.conf.get("channels") || {};
+    this.conf.set("channels", { ...current, [channel]: config });
+  }
+  // Config directory access
+  getConfigDir() {
+    return this.configDir;
+  }
+  getPatternsDir() {
+    return path.join(this.configDir, "patterns");
+  }
+  getTemplatesDir() {
+    return path.join(this.configDir, "templates");
+  }
+  getLearningDir() {
+    return path.join(this.configDir, "learning");
+  }
+  // Export/Import
+  exportConfig() {
+    return {
+      version: this.conf.get("version") || "1.0.0",
+      credentials: {},
+      // Don't export credentials
+      preferences: this.conf.get("preferences") || {},
+      learning: this.getLearning(),
+      projects: this.getProjects(),
+      channels: {}
+      // Don't export channel tokens
+    };
+  }
+  importConfig(config) {
+    if (config.preferences) {
+      this.conf.set("preferences", config.preferences);
+    }
+    if (config.learning) {
+      this.conf.set("learning", config.learning);
+    }
+  }
+};
+
+// src/utils/updates.ts
+import chalk from "chalk";
+var VERSION = "1.0.0";
+async function checkForUpdates() {
+  try {
+    const response = await fetch("https://registry.npmjs.org/codebakers/latest", {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!response.ok) return;
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (latestVersion && latestVersion !== VERSION) {
+      console.log(chalk.yellow(`
+\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E
+\u2502  Update available: ${VERSION} \u2192 ${latestVersion.padEnd(10)}        \u2502
+\u2502  Run: npm install -g codebakers            \u2502
+\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F
+`));
+    }
+  } catch {
+  }
+}
+
+// src/commands/setup.ts
+import * as p from "@clack/prompts";
+import chalk2 from "chalk";
+import open from "open";
+async function setupCommand() {
+  const config = new Config();
+  p.intro(chalk2.bgCyan.black(" CodeBakers Setup "));
+  if (config.isConfigured()) {
+    const action = await p.select({
+      message: "CodeBakers is already configured. What do you want to do?",
+      options: [
+        { value: "view", label: "\u{1F440} View connected services" },
+        { value: "add", label: "\u2795 Add another service" },
+        { value: "update", label: "\u{1F504} Update credentials" },
+        { value: "reset", label: "\u{1F5D1}\uFE0F  Reset all configuration" },
+        { value: "back", label: "\u2190 Back" }
+      ]
+    });
+    if (p.isCancel(action) || action === "back") {
+      return;
+    }
+    if (action === "view") {
+      showConnectedServices(config);
+      return;
+    }
+    if (action === "reset") {
+      const confirm6 = await p.confirm({
+        message: "Are you sure? This will remove all credentials and settings."
+      });
+      if (confirm6) {
+        p.outro(chalk2.yellow("Configuration reset. Run `codebakers setup` again."));
+      }
+      return;
+    }
+    if (action === "add") {
+      await addService(config);
+      return;
+    }
+  }
+  p.note(
+    `Let's connect your accounts. This only takes a few minutes.
+    
+${chalk2.dim("Your credentials are stored locally in ~/.codebakers/")}
+${chalk2.dim("and are never sent to our servers.")}`,
+    "Welcome to CodeBakers!"
+  );
+  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 }
+  ];
+  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...");
+  for (const service of requiredServices) {
+    await connectService(config, service.key, service.name, true);
+  }
+  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);
+        }
+      }
+    }
+  }
+  p.log.step("Installing CodeBakers patterns...");
+  await installPatterns(config);
+  p.outro(chalk2.green("\u2713 Setup complete! Run `codebakers init` to create your first project."));
+}
+async function connectService(config, serviceKey, serviceName, required) {
+  const spinner11 = p.spinner();
+  switch (serviceKey) {
+    case "github": {
+      p.log.info(`${chalk2.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;
+      }
+      p.log.info(chalk2.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 });
+        p.log.success("GitHub connected!");
+        return true;
+      }
+      break;
+    }
+    case "vercel": {
+      p.log.info(`${chalk2.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(chalk2.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 });
+        p.log.success("Vercel connected!");
+        return true;
+      }
+      break;
+    }
+    case "supabase": {
+      p.log.info(`${chalk2.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(chalk2.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 });
+        p.log.success("Supabase connected!");
+        return true;
+      }
+      break;
+    }
+    case "anthropic": {
+      p.log.info(`${chalk2.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 void 0;
+        }
+      });
+      if (!p.isCancel(apiKey) && apiKey) {
+        config.setCredentials("anthropic", { apiKey });
+        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 });
+        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 });
+        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,
+          authToken
+        });
+        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 });
+        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 });
+        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) {
+  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) {
+  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" + chalk2.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 ? chalk2.green("\u2713 Connected") : chalk2.dim("\u25CB Not connected");
+    console.log(`  ${service.name.padEnd(15)} ${status}`);
+  }
+  console.log("");
+}
+async function installPatterns(config) {
+  const patternsDir = config.getPatternsDir();
+  p.log.info(chalk2.dim(`Patterns installed to ${patternsDir}`));
+}
+
+// src/commands/init.ts
+import * as p2 from "@clack/prompts";
+import chalk3 from "chalk";
+import * as fs2 from "fs-extra";
+import * as path2 from "path";
+import { execa as execa2 } from "execa";
+
+// src/services/github.ts
+import { Octokit } from "@octokit/rest";
+var GitHubService = class {
+  octokit;
+  config;
+  constructor(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, options = {}) {
+    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() {
+    const response = await this.octokit.users.getAuthenticated();
+    return {
+      login: response.data.login,
+      name: response.data.name
+    };
+  }
+  async listRepos() {
+    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
+    }));
+  }
+};
+
+// src/services/vercel.ts
+import { execa } from "execa";
+var VercelService = class {
+  config;
+  token;
+  constructor(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) {
+    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, production = false) {
+    const args2 = ["vercel", "--yes"];
+    if (production) args2.push("--prod");
+    const result = await execa("npx", args2, {
+      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, domain) {
+    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 })
+    });
+  }
+};
+
+// src/services/supabase.ts
+var SupabaseService = class {
+  config;
+  accessToken;
+  constructor(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) {
+    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();
+    await this.waitForProject(data.id);
+    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
+    };
+  }
+  async getDefaultOrgId() {
+    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;
+  }
+  async waitForProject(projectId, maxWait = 12e4) {
+    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, 5e3));
+    }
+    throw new Error("Timeout waiting for Supabase project");
+  }
+  async getApiKeys(projectId) {
+    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) => k.name === "anon");
+    const serviceKey = keys.find((k) => k.name === "service_role");
+    return {
+      anon_key: anonKey?.api_key || "",
+      service_role_key: serviceKey?.api_key || ""
+    };
+  }
+  generatePassword() {
+    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() {
+    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((p14) => ({
+      id: p14.id,
+      name: p14.name,
+      region: p14.region
+    }));
+  }
+};
+
+// src/utils/claude-md.ts
+function generateClaudeMd(config) {
+  return `# ${config.name.toUpperCase()} - CLAUDE.md
+
+Generated by CodeBakers CLI
+
+---
+
+# CORE DEVELOPMENT STANDARDS
+
+## \u{1F9E0} MANDATORY THINKING PROTOCOL
+
+**BEFORE WRITING ANY CODE**, complete this mental checklist:
+
+\`\`\`
+\u25A2 What is the user actually asking for?
+\u25A2 What are ALL the components needed (UI, API, DB, types)?
+\u25A2 What are the edge cases?
+\u25A2 What error handling is required?
+\u25A2 What loading/empty states are needed?
+\u25A2 How does this integrate with existing code?
+\u25A2 What security implications exist?
+\u25A2 What could break in production?
+\`\`\`
+
+**NEVER skip this step.**
+
+---
+
+## \u{1F6AB} ABSOLUTE PROHIBITIONS
+
+These will NEVER appear in your code under ANY circumstances:
+
+\`\`\`typescript
+// \u274C 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
+
+// \u274C BANNED FOREVER - INCOMPLETE CODE
+TODO:                        // No TODOs ever
+FIXME:                       // No FIXMEs ever
+// ...                       // No placeholder comments
+throw new Error('Not implemented')
+
+// \u274C BANNED FOREVER - DEBUG CODE
+console.log('test')          // No debug logs in final code
+debugger;                    // No debugger statements
+
+// \u274C BANNED FOREVER - TYPE SAFETY VIOLATIONS
+any                          // No 'any' types
+@ts-ignore                   // No ignoring TypeScript
+as any                       // No casting to any
+
+// \u274C BANNED FOREVER - SECURITY VIOLATIONS
+eval()                       // No eval ever
+innerHTML =                  // No direct innerHTML
+dangerouslySetInnerHTML      // Without DOMPurify
+\`\`\`
+
+---
+
+## \u2705 MANDATORY PATTERNS
+
+### Every Button MUST Have:
+
+\`\`\`typescript
+// \u2705 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>
+  );
+}
+\`\`\`
+
+---
+
+## \u{1F4C1} PROJECT STRUCTURE
+
+\`\`\`
+${config.name}/
+\u251C\u2500\u2500 src/
+\u2502   \u251C\u2500\u2500 app/                    # Next.js App Router
+\u2502   \u2502   \u251C\u2500\u2500 (auth)/            # Routes requiring authentication
+\u2502   \u2502   \u251C\u2500\u2500 (public)/          # Public routes  
+\u2502   \u2502   \u251C\u2500\u2500 api/               # API routes
+\u2502   \u2502   \u2514\u2500\u2500 layout.tsx         # Root layout
+\u2502   \u251C\u2500\u2500 components/
+\u2502   \u2502   \u251C\u2500\u2500 ui/                # shadcn/ui components
+\u2502   \u2502   \u251C\u2500\u2500 forms/             # Form components
+\u2502   \u2502   \u2514\u2500\u2500 [feature]/         # Feature-specific
+\u2502   \u251C\u2500\u2500 lib/
+\u2502   \u2502   \u251C\u2500\u2500 supabase/          # Supabase clients
+\u2502   \u2502   \u251C\u2500\u2500 utils.ts           # Utilities
+\u2502   \u2502   \u2514\u2500\u2500 validations.ts     # Zod schemas
+\u2502   \u251C\u2500\u2500 hooks/                  # Custom hooks
+\u2502   \u251C\u2500\u2500 types/                  # TypeScript types
+\u2502   \u251C\u2500\u2500 stores/                 # Zustand stores
+\u2502   \u2514\u2500\u2500 services/              # Business logic
+\u251C\u2500\u2500 tests/                      # Playwright tests
+\u251C\u2500\u2500 .codebakers/               # CodeBakers config
+\u2514\u2500\u2500 CLAUDE.md                  # This file
+\`\`\`
+
+---
+
+## \u{1F510} 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
+
+---
+
+## \u{1F9EA} 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
+`;
+}
+
+// src/commands/init.ts
+async function initCommand(options = {}) {
+  const config = new Config();
+  if (!config.isConfigured()) {
+    p2.log.error("Please run `codebakers setup` first.");
+    return;
+  }
+  p2.intro(chalk3.bgCyan.black(" Create New Project "));
+  let projectName = options.name;
+  if (!projectName) {
+    const name = await p2.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 void 0;
+      }
+    });
+    if (p2.isCancel(name)) return;
+    projectName = name;
+  }
+  const projectType = await p2.select({
+    message: "What are you building?",
+    options: [
+      { value: "web", label: "\u{1F310} Web app", hint: "Next.js \u2192 Vercel" },
+      { value: "mobile", label: "\u{1F4F1} Mobile app", hint: "Expo \u2192 App stores" },
+      { value: "desktop", label: "\u{1F5A5}\uFE0F  Desktop app", hint: "Tauri \u2192 Windows/Mac/Linux" },
+      { value: "fullstack", label: "\u{1F4E6} Full stack", hint: "Web + Mobile + Desktop" }
+    ]
+  });
+  if (p2.isCancel(projectType)) return;
+  let framework = "nextjs";
+  if (projectType === "web" || projectType === "fullstack") {
+    const selected = await p2.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 (p2.isCancel(selected)) return;
+    framework = selected;
+    config.learnPreference("defaultFramework", framework);
+  }
+  const uiLibrary = await p2.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 (p2.isCancel(uiLibrary)) return;
+  config.learnPreference("defaultUI", uiLibrary);
+  const packages = await p2.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 (p2.isCancel(packages)) return;
+  const services = await p2.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 (p2.isCancel(services)) return;
+  let domain;
+  const domainChoice = await p2.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 (p2.isCancel(domainChoice)) return;
+  if (domainChoice === "subdomain") {
+    const sub = await p2.text({
+      message: "Subdomain:",
+      placeholder: projectName,
+      initialValue: projectName
+    });
+    if (!p2.isCancel(sub)) {
+      domain = `${sub}.yourdomain.com`;
+    }
+  }
+  const projectConfig = {
+    name: projectName,
+    type: projectType,
+    framework,
+    ui: uiLibrary,
+    packages,
+    services,
+    domain
+  };
+  p2.note(
+    `Name:       ${projectName}
+Type:       ${projectType}
+Framework:  ${framework}
+UI:         ${uiLibrary}
+Packages:   ${packages.join(", ")}
+Services:   ${services.join(", ")}
+Domain:     ${domain || "Vercel default"}`,
+    "Configuration"
+  );
+  const confirmed = await p2.confirm({
+    message: "Create project?",
+    initialValue: true
+  });
+  if (!confirmed || p2.isCancel(confirmed)) {
+    p2.cancel("Project creation cancelled.");
+    return;
+  }
+  const spinner11 = p2.spinner();
+  const projectPath = path2.join(process.cwd(), projectName);
+  try {
+    spinner11.start("Creating local project...");
+    await createLocalProject(projectPath, projectConfig);
+    spinner11.stop("Local project created");
+    spinner11.start("Installing dependencies...");
+    await execa2("pnpm", ["install"], { cwd: projectPath });
+    spinner11.stop("Dependencies installed");
+    if (services.includes("github")) {
+      spinner11.start("Creating GitHub repository...");
+      const github = new GitHubService(config);
+      const repo = await github.createRepo(projectName, { private: true });
+      spinner11.stop(`GitHub repo created: ${repo.html_url}`);
+      await execa2("git", ["init"], { cwd: projectPath });
+      await execa2("git", ["add", "."], { cwd: projectPath });
+      await execa2("git", ["commit", "-m", "Initial commit by CodeBakers"], { cwd: projectPath });
+      await execa2("git", ["remote", "add", "origin", repo.clone_url], { cwd: projectPath });
+      await execa2("git", ["push", "-u", "origin", "main"], { cwd: projectPath });
+    }
+    if (services.includes("supabase")) {
+      spinner11.start("Creating Supabase project...");
+      const supabase = new SupabaseService(config);
+      const project = await supabase.createProject(projectName);
+      spinner11.stop(`Supabase project created: ${project.name}`);
+      await fs2.writeJson(
+        path2.join(projectPath, ".codebakers", "supabase.json"),
+        { projectId: project.id, projectUrl: project.api_url },
+        { spaces: 2 }
+      );
+    }
+    if (services.includes("vercel")) {
+      spinner11.start("Creating Vercel project...");
+      const vercel = new VercelService(config);
+      const project = await vercel.createProject(projectName);
+      spinner11.stop(`Vercel project created`);
+      if (domain) {
+        spinner11.start(`Configuring domain: ${domain}...`);
+        await vercel.addDomain(projectName, domain);
+        spinner11.stop("Domain configured");
+      }
+      spinner11.start("Deploying to Vercel...");
+      const deployment = await vercel.deploy(projectPath);
+      spinner11.stop(`Deployed: ${deployment.url}`);
+    }
+    spinner11.start("Generating CLAUDE.md...");
+    const claudeMd = generateClaudeMd(projectConfig);
+    await fs2.writeFile(path2.join(projectPath, "CLAUDE.md"), claudeMd);
+    spinner11.stop("CLAUDE.md generated");
+    spinner11.start("Setting up CodeBakers enforcement...");
+    await setupGitHooks(projectPath);
+    spinner11.stop("CodeBakers enforcement configured");
+    config.addProject({
+      name: projectName,
+      path: projectPath,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    p2.outro(chalk3.green(`
+\u2713 Project created!
+
+${chalk3.bold("Your project is ready:")}
+  ${chalk3.cyan(`cd ${projectName}`)}
+  ${chalk3.cyan("codebakers code")}
+
+${chalk3.dim("Shortcuts:")}
+  ${chalk3.cyan("codebakers")} \u2014 Interactive menu
+  ${chalk3.cyan("codebakers code")} \u2014 AI coding agent
+  ${chalk3.cyan("codebakers check")} \u2014 Pattern enforcement
+  ${chalk3.cyan("codebakers deploy")} \u2014 Deploy to production
+`));
+  } catch (error) {
+    spinner11.stop("Error occurred");
+    p2.log.error(`Failed to create project: ${error instanceof Error ? error.message : "Unknown error"}`);
+    const cleanup = await p2.confirm({
+      message: "Clean up partially created project?"
+    });
+    if (cleanup && !p2.isCancel(cleanup)) {
+      await fs2.remove(projectPath);
+      p2.log.info("Cleaned up.");
+    }
+  }
+}
+async function createLocalProject(projectPath, config) {
+  const framework = config.framework;
+  const ui = config.ui;
+  const packages = config.packages;
+  await fs2.ensureDir(projectPath);
+  await fs2.ensureDir(path2.join(projectPath, ".codebakers"));
+  await fs2.ensureDir(path2.join(projectPath, "src", "app"));
+  await fs2.ensureDir(path2.join(projectPath, "src", "components", "ui"));
+  await fs2.ensureDir(path2.join(projectPath, "src", "components", "features"));
+  await fs2.ensureDir(path2.join(projectPath, "src", "lib"));
+  await fs2.ensureDir(path2.join(projectPath, "src", "hooks"));
+  await fs2.ensureDir(path2.join(projectPath, "src", "types"));
+  await fs2.ensureDir(path2.join(projectPath, "src", "stores"));
+  await fs2.ensureDir(path2.join(projectPath, "src", "services"));
+  const packageJson = {
+    name: path2.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"
+    }
+  };
+  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";
+  }
+  packageJson.dependencies["@supabase/supabase-js"] = "^2.45.0";
+  packageJson.dependencies["@supabase/ssr"] = "^0.4.0";
+  await fs2.writeJson(path2.join(projectPath, "package.json"), packageJson, { spaces: 2 });
+  await createConfigFiles(projectPath, config);
+  await fs2.writeJson(
+    path2.join(projectPath, ".codebakers", "config.json"),
+    {
+      version: "1.0.0",
+      framework,
+      ui,
+      packages,
+      patterns: ["00-core", "01-database", "02-auth", "03-api", "04-frontend"],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    { spaces: 2 }
+  );
+}
+async function createConfigFiles(projectPath, 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 fs2.writeJson(path2.join(projectPath, "tsconfig.json"), tsConfig, { spaces: 2 });
+  const nextConfig = `/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    typedRoutes: true,
+  },
+};
+
+export default nextConfig;
+`;
+  await fs2.writeFile(path2.join(projectPath, "next.config.mjs"), nextConfig);
+  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 fs2.writeFile(path2.join(projectPath, "tailwind.config.ts"), tailwindConfig);
+  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 fs2.writeFile(path2.join(projectPath, ".env.example"), envExample);
+  await fs2.writeFile(path2.join(projectPath, ".env.local"), envExample);
+  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 fs2.writeFile(path2.join(projectPath, ".gitignore"), gitignore);
+}
+async function setupGitHooks(projectPath) {
+  const hooksDir = path2.join(projectPath, ".git", "hooks");
+  if (!await fs2.pathExists(path2.join(projectPath, ".git"))) {
+    await execa2("git", ["init"], { cwd: projectPath });
+  }
+  await fs2.ensureDir(hooksDir);
+  const preCommitHook = `#!/bin/sh
+# CodeBakers pre-commit hook
+
+echo "\u{1F50D} Running CodeBakers check..."
+
+# Run pattern check
+codebakers check
+
+# If check fails, abort commit
+if [ $? -ne 0 ]; then
+  echo "\u274C CodeBakers check failed. Fix issues or use --no-verify to bypass."
+  exit 1
+fi
+
+echo "\u2713 CodeBakers check passed"
+`;
+  await fs2.writeFile(path2.join(hooksDir, "pre-commit"), preCommitHook);
+  await fs2.chmod(path2.join(hooksDir, "pre-commit"), "755");
+}
+
+// src/commands/code.ts
+import * as p4 from "@clack/prompts";
+import chalk5 from "chalk";
+import * as fs5 from "fs-extra";
+import * as path5 from "path";
+import Anthropic from "@anthropic-ai/sdk";
+import { execa as execa3 } from "execa";
+
+// src/patterns/loader.ts
+import * as fs3 from "fs-extra";
+import * as path3 from "path";
+var CORE_PATTERNS = `
+# CODEBAKERS CORE PATTERNS
+
+## ABSOLUTE PROHIBITIONS
+
+These will NEVER appear in your code:
+
+\`\`\`typescript
+// \u274C 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
+
+// \u274C BANNED - INCOMPLETE CODE
+TODO:                       // No TODOs ever
+FIXME:                      // No FIXMEs ever
+// ...                      // No placeholder comments
+throw new Error('Not implemented')
+
+// \u274C BANNED - DEBUG CODE
+console.log('test')         // No debug logs
+debugger;                   // No debugger statements
+
+// \u274C BANNED - TYPE SAFETY VIOLATIONS
+any                         // No 'any' types
+@ts-ignore                  // No ignoring TypeScript
+as any                      // No casting to any
+
+// \u274C 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/
+\u251C\u2500\u2500 app/                    # Next.js App Router
+\u2502   \u251C\u2500\u2500 (auth)/            # Routes requiring authentication
+\u2502   \u251C\u2500\u2500 (public)/          # Public routes
+\u2502   \u251C\u2500\u2500 (marketing)/       # Marketing pages
+\u2502   \u251C\u2500\u2500 api/               # API routes
+\u2502   \u2514\u2500\u2500 layout.tsx         # Root layout
+\u251C\u2500\u2500 components/
+\u2502   \u251C\u2500\u2500 ui/                # shadcn/ui components
+\u2502   \u251C\u2500\u2500 forms/             # Form components
+\u2502   \u251C\u2500\u2500 layouts/           # Layout components
+\u2502   \u2514\u2500\u2500 [feature]/         # Feature-specific components
+\u251C\u2500\u2500 lib/
+\u2502   \u251C\u2500\u2500 supabase/          # Supabase clients
+\u2502   \u251C\u2500\u2500 utils.ts           # Utility functions
+\u2502   \u2514\u2500\u2500 validations.ts     # Zod schemas
+\u251C\u2500\u2500 hooks/                  # Custom React hooks
+\u251C\u2500\u2500 types/                  # TypeScript types
+\u251C\u2500\u2500 stores/                 # Zustand stores
+\u2514\u2500\u2500 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);
+  }
+}
+\`\`\`
+`;
+async function loadPatterns(config) {
+  const projectDir = process.cwd();
+  const patterns = [CORE_PATTERNS];
+  const projectPatternDir = path3.join(projectDir, ".codebakers", "patterns");
+  if (await fs3.pathExists(projectPatternDir)) {
+    const files = await fs3.readdir(projectPatternDir);
+    for (const file of files) {
+      if (file.endsWith(".md")) {
+        const content = await fs3.readFile(path3.join(projectPatternDir, file), "utf-8");
+        patterns.push(content);
+      }
+    }
+  }
+  const globalPatternDir = config.getPatternsDir();
+  if (await fs3.pathExists(globalPatternDir)) {
+    const files = await fs3.readdir(globalPatternDir);
+    for (const file of files.slice(0, 10)) {
+      if (file.endsWith(".md")) {
+        const content = await fs3.readFile(path3.join(globalPatternDir, file), "utf-8");
+        patterns.push(content.slice(0, 1e4));
+      }
+    }
+  }
+  return patterns.join("\n\n---\n\n");
+}
+
+// src/commands/check.ts
+import * as p3 from "@clack/prompts";
+import chalk4 from "chalk";
+import * as fs4 from "fs-extra";
+import * as path4 from "path";
+import glob from "fast-glob";
+var RULES = [
+  {
+    id: "no-any",
+    name: "No any type",
+    description: 'Avoid using the "any" type',
+    severity: "error",
+    pattern: /:\s*any\b(?!\s*\=\>)/g,
+    message: 'Avoid using "any" type. Use proper TypeScript types.',
+    autoFixable: false
+  },
+  {
+    id: "no-ts-ignore",
+    name: "No @ts-ignore",
+    description: "Avoid using @ts-ignore",
+    severity: "error",
+    pattern: /@ts-ignore/g,
+    message: "@ts-ignore bypasses type checking. Fix the underlying issue.",
+    autoFixable: false
+  },
+  {
+    id: "no-console-log",
+    name: "No console.log",
+    description: "Remove debug console.log statements",
+    severity: "warning",
+    pattern: /console\.log\(/g,
+    message: "Remove console.log before committing. Use proper logging.",
+    autoFixable: true
+  },
+  {
+    id: "no-todo",
+    name: "No TODO comments",
+    description: "Complete all TODOs before committing",
+    severity: "warning",
+    pattern: /\/\/\s*TODO:/gi,
+    message: "Complete or remove TODO comments before committing.",
+    autoFixable: false
+  },
+  {
+    id: "no-fixme",
+    name: "No FIXME comments",
+    description: "Fix all FIXME issues before committing",
+    severity: "error",
+    pattern: /\/\/\s*FIXME:/gi,
+    message: "Address FIXME issues before committing.",
+    autoFixable: false
+  },
+  {
+    id: "button-has-handler",
+    name: "Button has onClick",
+    description: "Buttons should have onClick handlers",
+    severity: "error",
+    pattern: /<Button[^>]*(?!onClick)[^>]*>/g,
+    message: "Button must have an onClick handler.",
+    autoFixable: false,
+    validator: (content, match) => {
+      const buttonTag = match[0];
+      return !buttonTag.includes("onClick") && !buttonTag.includes('type="submit"');
+    }
+  },
+  {
+    id: "async-has-try-catch",
+    name: "Async has try/catch",
+    description: "Async functions should have error handling",
+    severity: "error",
+    pattern: /async\s+(?:function\s+\w+|\([^)]*\)\s*=>|\w+\s*=\s*async\s*\([^)]*\)\s*=>)\s*\{[^}]*\}/g,
+    message: "Async function should have try/catch error handling.",
+    autoFixable: false,
+    validator: (content, match) => {
+      const funcBody = match[0];
+      return !funcBody.includes("try") && !funcBody.includes("catch");
+    }
+  },
+  {
+    id: "no-hardcoded-secrets",
+    name: "No hardcoded secrets",
+    description: "Secrets should be in environment variables",
+    severity: "error",
+    pattern: /(sk_live_|sk_test_|pk_live_|pk_test_|api_key\s*=\s*['"][^'"]+['"])/gi,
+    message: "Possible hardcoded secret. Use environment variables.",
+    autoFixable: false
+  },
+  {
+    id: "no-eval",
+    name: "No eval()",
+    description: "Never use eval() - security risk",
+    severity: "error",
+    pattern: /\beval\s*\(/g,
+    message: "Never use eval(). It is a security vulnerability.",
+    autoFixable: false
+  },
+  {
+    id: "no-innerhtml",
+    name: "No innerHTML",
+    description: "Avoid direct innerHTML assignment",
+    severity: "error",
+    pattern: /\.innerHTML\s*=/g,
+    message: "Avoid innerHTML. Use proper React rendering or DOMPurify.",
+    autoFixable: false
+  },
+  {
+    id: "loading-state",
+    name: "Loading state in components",
+    description: "Components with fetch should have loading states",
+    severity: "warning",
+    pattern: /useEffect\s*\([^)]*fetch\([^)]*\)/g,
+    message: "Components fetching data should have loading states.",
+    autoFixable: false,
+    validator: (content) => {
+      return content.includes("fetch(") && !content.includes("isLoading") && !content.includes("loading") && !content.includes("isPending");
+    }
+  },
+  {
+    id: "form-validation",
+    name: "Form has validation",
+    description: "Forms should use Zod validation",
+    severity: "warning",
+    pattern: /<form[^>]*onSubmit/gi,
+    message: "Forms should use Zod schema validation.",
+    autoFixable: false,
+    validator: (content) => {
+      return content.includes("<form") && !content.includes("zodResolver") && !content.includes("z.object");
+    }
+  },
+  {
+    id: "use-client-directive",
+    name: "use client directive",
+    description: 'Client components should have "use client" directive',
+    severity: "error",
+    pattern: /(useState|useEffect|useReducer|useContext|useRef|useCallback|useMemo)\s*\(/g,
+    message: 'Components using hooks must have "use client" directive.',
+    autoFixable: true,
+    validator: (content) => {
+      const hasHooks = /(useState|useEffect|useReducer|useContext|useRef|useCallback|useMemo)\s*\(/.test(content);
+      const hasDirective = content.trim().startsWith("'use client'") || content.trim().startsWith('"use client"');
+      return hasHooks && !hasDirective;
+    }
+  },
+  {
+    id: "key-prop-in-map",
+    name: "Key prop in map",
+    description: "Elements in .map() should have key prop",
+    severity: "error",
+    pattern: /\.map\s*\([^)]*\)\s*=>\s*(?:\(?\s*<[A-Z][^>]*(?!key=)[^>]*>)/g,
+    message: "Elements in .map() must have a unique key prop.",
+    autoFixable: false
+  }
+];
+async function checkCommand(options = {}) {
+  const config = new Config();
+  if (!config.isInProject()) {
+    p3.log.error("Not in a CodeBakers project.");
+    return;
+  }
+  p3.intro(chalk4.bgCyan.black(" CodeBakers Pattern Check "));
+  const spinner11 = p3.spinner();
+  spinner11.start("Analyzing code...");
+  const result = await runPatternCheck(options.fix || false);
+  spinner11.stop("Analysis complete");
+  displayResults(result);
+  if (result.violations.length > 0 && options.fix) {
+    const fixable = result.violations.filter((v) => v.autoFixable);
+    if (fixable.length > 0) {
+      spinner11.start(`Auto-fixing ${fixable.length} violations...`);
+      await autoFix(fixable);
+      spinner11.stop("Auto-fix complete");
+    }
+  }
+  const errors = result.violations.filter((v) => v.severity === "error");
+  if (errors.length > 0) {
+    p3.outro(chalk4.red(`\u274C ${errors.length} errors found. Fix before committing.`));
+    process.exit(1);
+  } else if (result.violations.length > 0) {
+    p3.outro(chalk4.yellow(`\u26A0\uFE0F  ${result.violations.length} warnings. Consider fixing.`));
+  } else {
+    p3.outro(chalk4.green("\u2713 All patterns satisfied!"));
+  }
+}
+async function runPatternCheck(autoFix2) {
+  const cwd = process.cwd();
+  const violations = [];
+  const files = await glob(["src/**/*.{ts,tsx,js,jsx}"], {
+    cwd,
+    ignore: ["**/node_modules/**", "**/.next/**", "**/dist/**"]
+  });
+  for (const file of files) {
+    const filePath = path4.join(cwd, file);
+    const content = await fs4.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    for (const rule of RULES) {
+      if (rule.validator) {
+        const regex = new RegExp(rule.pattern.source, rule.pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+          if (rule.validator(content, match)) {
+            const line = content.substring(0, match.index).split("\n").length;
+            violations.push({
+              file,
+              line,
+              rule: rule.id,
+              message: rule.message,
+              severity: rule.severity,
+              autoFixable: rule.autoFixable
+            });
+            break;
+          }
+        }
+      } else {
+        const regex = new RegExp(rule.pattern.source, rule.pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+          const line = content.substring(0, match.index).split("\n").length;
+          violations.push({
+            file,
+            line,
+            rule: rule.id,
+            message: rule.message,
+            severity: rule.severity,
+            autoFixable: rule.autoFixable
+          });
+        }
+      }
+    }
+  }
+  return {
+    violations,
+    filesChecked: files.length,
+    passed: violations.length === 0
+  };
+}
+function displayResults(result) {
+  console.log(chalk4.dim(`
+Checked ${result.filesChecked} files
+`));
+  if (result.violations.length === 0) {
+    console.log(chalk4.green("  \u2713 No violations found\n"));
+    return;
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const v of result.violations) {
+    if (!byFile.has(v.file)) {
+      byFile.set(v.file, []);
+    }
+    byFile.get(v.file).push(v);
+  }
+  for (const [file, fileViolations] of byFile) {
+    console.log(chalk4.bold(file));
+    for (const v of fileViolations) {
+      const icon = v.severity === "error" ? chalk4.red("\u2717") : chalk4.yellow("\u26A0");
+      const fixable = v.autoFixable ? chalk4.dim(" (auto-fixable)") : "";
+      console.log(`  ${icon} Line ${v.line}: ${v.message}${fixable}`);
+    }
+    console.log("");
+  }
+  const errors = result.violations.filter((v) => v.severity === "error").length;
+  const warnings = result.violations.filter((v) => v.severity === "warning").length;
+  console.log(chalk4.bold("Summary:"));
+  if (errors > 0) {
+    console.log(chalk4.red(`  ${errors} error(s)`));
+  }
+  if (warnings > 0) {
+    console.log(chalk4.yellow(`  ${warnings} warning(s)`));
+  }
+  console.log("");
+}
+async function autoFix(violations) {
+  const cwd = process.cwd();
+  const byFile = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    if (!byFile.has(v.file)) {
+      byFile.set(v.file, []);
+    }
+    byFile.get(v.file).push(v);
+  }
+  for (const [file, fileViolations] of byFile) {
+    const filePath = path4.join(cwd, file);
+    let content = await fs4.readFile(filePath, "utf-8");
+    for (const v of fileViolations) {
+      switch (v.rule) {
+        case "no-console-log":
+          content = content.replace(/console\.log\([^)]*\);?\n?/g, "");
+          break;
+        case "use-client-directive":
+          if (!content.startsWith("'use client'") && !content.startsWith('"use client"')) {
+            content = "'use client';\n\n" + content;
+          }
+          break;
+      }
+    }
+    await fs4.writeFile(filePath, content);
+  }
+}
+
+// src/commands/code.ts
+async function codeCommand(prompt, options = {}) {
+  const config = new Config();
+  if (!config.isConfigured()) {
+    p4.log.error("Please run `codebakers setup` first.");
+    return;
+  }
+  if (!config.isInProject()) {
+    p4.log.error("Not in a CodeBakers project. Run `codebakers init` first.");
+    return;
+  }
+  const anthropicCreds = config.getCredentials("anthropic");
+  if (!anthropicCreds?.apiKey) {
+    p4.log.error("Anthropic API key not configured. Run `codebakers setup`.");
+    return;
+  }
+  const anthropic = new Anthropic({
+    apiKey: anthropicCreds.apiKey
+  });
+  const projectContext = await loadProjectContext();
+  const patterns = await loadPatterns(config);
+  const systemPrompt = buildSystemPrompt(projectContext, patterns);
+  console.log(chalk5.cyan(`
+\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E
+\u2502  \u{1F916} CodeBakers AI                                   \u2502
+\u2502                                                     \u2502
+\u2502  Project: ${projectContext.name.padEnd(38)}\u2502
+\u2502  Stack: ${`${projectContext.framework} + ${projectContext.ui}`.padEnd(40)}\u2502
+\u2502                                                     \u2502
+\u2502  Type your request or "?" for help                  \u2502
+\u2502  Type "exit" or Ctrl+C to quit                      \u2502
+\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F
+`));
+  const messages = [];
+  if (prompt) {
+    await processUserInput(prompt, messages, anthropic, systemPrompt, projectContext, config);
+  }
+  while (true) {
+    const input = await p4.text({
+      message: "",
+      placeholder: "What do you want to build?"
+    });
+    if (p4.isCancel(input)) {
+      p4.outro("Goodbye!");
+      break;
+    }
+    const userInput = input.trim();
+    if (!userInput) continue;
+    if (userInput.toLowerCase() === "exit") {
+      p4.outro("Goodbye!");
+      break;
+    }
+    if (userInput === "?") {
+      showHelp();
+      continue;
+    }
+    if (userInput.startsWith("/")) {
+      await handleSlashCommand(userInput, projectContext, config);
+      continue;
+    }
+    await processUserInput(userInput, messages, anthropic, systemPrompt, projectContext, config);
+  }
+}
+async function processUserInput(userInput, messages, anthropic, systemPrompt, projectContext, config) {
+  const spinner11 = p4.spinner();
+  messages.push({ role: "user", content: userInput });
+  const wizardResult = await checkForWizard(userInput);
+  if (wizardResult) {
+    messages[messages.length - 1].content = wizardResult;
+  }
+  try {
+    spinner11.start("Thinking...");
+    const response = await anthropic.messages.create({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 8192,
+      system: systemPrompt,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }))
+    });
+    spinner11.stop("");
+    const assistantMessage = response.content[0].type === "text" ? response.content[0].text : "";
+    messages.push({ role: "assistant", content: assistantMessage });
+    const actions = parseActions(assistantMessage);
+    if (actions.length > 0) {
+      console.log(chalk5.cyan("\n\u{1F4CB} Plan:"));
+      actions.forEach((action, i) => {
+        console.log(chalk5.dim(`  ${i + 1}. ${action.description}`));
+      });
+      console.log("");
+      const proceed = await p4.confirm({
+        message: "Execute this plan?",
+        initialValue: true
+      });
+      if (proceed && !p4.isCancel(proceed)) {
+        spinner11.start("Building...");
+        for (const action of actions) {
+          await executeAction(action, spinner11);
+        }
+        spinner11.stop("Build complete");
+        console.log(chalk5.dim("\n\u{1F50D} Running CodeBakers check..."));
+        const checkResult = await runPatternCheck(false);
+        if (checkResult.violations.length > 0) {
+          console.log(chalk5.yellow(`
+\u26A0\uFE0F  ${checkResult.violations.length} pattern violations found`));
+          const autoFix2 = await p4.confirm({
+            message: "Auto-fix violations?",
+            initialValue: true
+          });
+          if (autoFix2 && !p4.isCancel(autoFix2)) {
+            spinner11.start("Auto-fixing...");
+            await autoFixViolations(checkResult.violations, anthropic, systemPrompt);
+            spinner11.stop("Violations fixed");
+          }
+        } else {
+          console.log(chalk5.green("\u2713 All patterns satisfied"));
+        }
+        projectContext.recentChanges.push(...actions.map((a) => a.description));
+      }
+    } else {
+      console.log("\n" + assistantMessage + "\n");
+    }
+  } catch (error) {
+    spinner11.stop("Error");
+    console.log(chalk5.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+  }
+}
+function buildSystemPrompt(context, patterns) {
+  return `You are CodeBakers, an AI coding assistant that ALWAYS follows the user's patterns and rules.
+
+PROJECT CONTEXT:
+- Name: ${context.name}
+- Framework: ${context.framework}
+- UI Library: ${context.ui}
+- Packages: ${context.packages.join(", ")}
+
+EXISTING FILES:
+${context.existingFiles.slice(0, 50).join("\n")}
+
+RECENT CHANGES:
+${context.recentChanges.slice(-10).join("\n")}
+
+CODEBAKERS PATTERNS (MUST FOLLOW):
+${patterns}
+
+INSTRUCTIONS:
+1. ALWAYS follow the patterns above - they are non-negotiable
+2. When creating code, output it in this format:
+   
+   <<<ACTION:CREATE_FILE>>>
+   PATH: src/path/to/file.tsx
+   DESCRIPTION: Brief description
+   <<<CONTENT>>>
+   // file content here
+   <<<END_CONTENT>>>
+   <<<END_ACTION>>>
+
+3. For editing files:
+   
+   <<<ACTION:EDIT_FILE>>>
+   PATH: src/path/to/file.tsx
+   DESCRIPTION: What you're changing
+   <<<FIND>>>
+   // code to find
+   <<<REPLACE>>>
+   // replacement code
+   <<<END_ACTION>>>
+
+4. For running commands:
+   
+   <<<ACTION:RUN_COMMAND>>>
+   COMMAND: pnpm add some-package
+   DESCRIPTION: Why running this
+   <<<END_ACTION>>>
+
+5. Every button MUST have a working onClick handler
+6. Every form MUST have proper validation with Zod
+7. Every async operation MUST have loading, error, and success states
+8. Every list MUST have empty state handling
+9. Use Zustand for state management, not prop drilling
+10. Put files in the correct folders as specified in patterns
+
+If you're unsure about requirements, ask clarifying questions before coding.
+`;
+}
+async function loadProjectContext() {
+  const cwd = process.cwd();
+  const codebakersConfig = path5.join(cwd, ".codebakers", "config.json");
+  let projectConfig = {};
+  if (await fs5.pathExists(codebakersConfig)) {
+    projectConfig = await fs5.readJson(codebakersConfig);
+  }
+  const glob3 = (await import("fast-glob")).default;
+  const files = await glob3(["src/**/*.{ts,tsx,js,jsx}"], { cwd });
+  return {
+    name: path5.basename(cwd),
+    framework: projectConfig.framework || "nextjs",
+    ui: projectConfig.ui || "shadcn",
+    packages: projectConfig.packages || [],
+    existingFiles: files,
+    recentChanges: []
+  };
+}
+function parseActions(response) {
+  const actions = [];
+  const createFileRegex = /<<<ACTION:CREATE_FILE>>>\s*PATH:\s*(.+?)\s*DESCRIPTION:\s*(.+?)\s*<<<CONTENT>>>\s*([\s\S]+?)\s*<<<END_CONTENT>>>\s*<<<END_ACTION>>>/g;
+  let match;
+  while ((match = createFileRegex.exec(response)) !== null) {
+    actions.push({
+      type: "CREATE_FILE",
+      path: match[1].trim(),
+      description: match[2].trim(),
+      content: match[3].trim()
+    });
+  }
+  const editFileRegex = /<<<ACTION:EDIT_FILE>>>\s*PATH:\s*(.+?)\s*DESCRIPTION:\s*(.+?)\s*<<<FIND>>>\s*([\s\S]+?)\s*<<<REPLACE>>>\s*([\s\S]+?)\s*<<<END_ACTION>>>/g;
+  while ((match = editFileRegex.exec(response)) !== null) {
+    actions.push({
+      type: "EDIT_FILE",
+      path: match[1].trim(),
+      description: match[2].trim(),
+      find: match[3].trim(),
+      replace: match[4].trim()
+    });
+  }
+  const runCommandRegex = /<<<ACTION:RUN_COMMAND>>>\s*COMMAND:\s*(.+?)\s*DESCRIPTION:\s*(.+?)\s*<<<END_ACTION>>>/g;
+  while ((match = runCommandRegex.exec(response)) !== null) {
+    actions.push({
+      type: "RUN_COMMAND",
+      command: match[1].trim(),
+      description: match[2].trim()
+    });
+  }
+  return actions;
+}
+async function executeAction(action, spinner11) {
+  const cwd = process.cwd();
+  switch (action.type) {
+    case "CREATE_FILE": {
+      const filePath = path5.join(cwd, action.path);
+      await fs5.ensureDir(path5.dirname(filePath));
+      await fs5.writeFile(filePath, action.content);
+      spinner11.message(`Created ${action.path}`);
+      break;
+    }
+    case "EDIT_FILE": {
+      const filePath = path5.join(cwd, action.path);
+      if (await fs5.pathExists(filePath)) {
+        let content = await fs5.readFile(filePath, "utf-8");
+        if (action.find && content.includes(action.find)) {
+          content = content.replace(action.find, action.replace || "");
+          await fs5.writeFile(filePath, content);
+          spinner11.message(`Edited ${action.path}`);
+        }
+      }
+      break;
+    }
+    case "RUN_COMMAND": {
+      spinner11.message(`Running: ${action.command}`);
+      const [cmd, ...args2] = action.command.split(" ");
+      await execa3(cmd, args2, { cwd, stdio: "pipe" });
+      break;
+    }
+    case "DELETE_FILE": {
+      const filePath = path5.join(cwd, action.path);
+      if (await fs5.pathExists(filePath)) {
+        await fs5.remove(filePath);
+        spinner11.message(`Deleted ${action.path}`);
+      }
+      break;
+    }
+  }
+}
+async function checkForWizard(input) {
+  const lower = input.toLowerCase();
+  if (lower.includes("add") || lower.includes("create") || lower.includes("build")) {
+    if (lower.includes("auth") || lower.includes("login") || lower.includes("signup")) {
+      return await runAuthWizard(input);
+    }
+    if (lower.includes("payment") || lower.includes("checkout") || lower.includes("stripe")) {
+      return await runPaymentWizard(input);
+    }
+    if (lower.includes("form")) {
+      return await runFormWizard(input);
+    }
+    if (lower.includes("dashboard")) {
+      return await runDashboardWizard(input);
+    }
+    if (lower.includes("chat") || lower.includes("ai")) {
+      return await runAIWizard(input);
+    }
+  }
+  return null;
+}
+async function runAuthWizard(originalInput) {
+  console.log(chalk5.cyan("\n\u{1F510} Auth Wizard"));
+  const authType = await p4.select({
+    message: "What type of authentication?",
+    options: [
+      { value: "magic-link", label: "\u{1F517} Magic link (email)" },
+      { value: "password", label: "\u{1F511} Password (email + password)" },
+      { value: "social", label: "\u{1F310} Social login (Google, GitHub)" },
+      { value: "phone", label: "\u{1F4F1} Phone (SMS code)" }
+    ]
+  });
+  if (p4.isCancel(authType)) return originalInput;
+  const pages = await p4.multiselect({
+    message: "What pages do you need?",
+    options: [
+      { value: "login", label: "Login page" },
+      { value: "signup", label: "Signup page" },
+      { value: "forgot", label: "Forgot password" },
+      { value: "reset", label: "Reset password" },
+      { value: "verify", label: "Email verification" }
+    ],
+    initialValues: ["login", "signup"]
+  });
+  if (p4.isCancel(pages)) return originalInput;
+  const redirect = await p4.text({
+    message: "Where should users go after login?",
+    placeholder: "/dashboard",
+    initialValue: "/dashboard"
+  });
+  return `Create a complete authentication system with:
+- Auth type: ${authType}
+- Pages: ${pages.join(", ")}
+- Redirect after login: ${redirect}
+- Use Supabase Auth
+- Include loading states, error handling, form validation
+- Follow all CodeBakers patterns`;
+}
+async function runPaymentWizard(originalInput) {
+  console.log(chalk5.cyan("\n\u{1F4B3} Payment Wizard"));
+  const paymentType = await p4.select({
+    message: "What type of payment flow?",
+    options: [
+      { value: "one-time", label: "\u{1F4B5} One-time purchase" },
+      { value: "subscription", label: "\u{1F504} Subscription (recurring)" },
+      { value: "both", label: "\u{1F4E6} Both" }
+    ]
+  });
+  if (p4.isCancel(paymentType)) return originalInput;
+  const features = await p4.multiselect({
+    message: "What features?",
+    options: [
+      { value: "checkout", label: "Checkout page" },
+      { value: "webhook", label: "Webhook handler" },
+      { value: "portal", label: "Customer portal" },
+      { value: "invoices", label: "Invoice history" }
+    ],
+    initialValues: ["checkout", "webhook"]
+  });
+  if (p4.isCancel(features)) return originalInput;
+  return `Create a complete Stripe payment system with:
+- Payment type: ${paymentType}
+- Features: ${features.join(", ")}
+- Use Stripe SDK
+- Include webhook signature verification
+- Handle all error cases
+- Follow all CodeBakers patterns`;
+}
+async function runFormWizard(originalInput) {
+  console.log(chalk5.cyan("\n\u{1F4DD} Form Wizard"));
+  const formName = await p4.text({
+    message: "What is this form for?",
+    placeholder: "Contact form"
+  });
+  if (p4.isCancel(formName)) return originalInput;
+  return `Create a ${formName} form with:
+- React Hook Form for form handling
+- Zod validation schema
+- Loading state during submission
+- Error messages for each field
+- Success toast on completion
+- Proper accessibility (aria labels)
+- Follow all CodeBakers patterns`;
+}
+async function runDashboardWizard(originalInput) {
+  console.log(chalk5.cyan("\n\u{1F4CA} Dashboard Wizard"));
+  const components = await p4.multiselect({
+    message: "What components?",
+    options: [
+      { value: "stats", label: "Stats cards" },
+      { value: "chart", label: "Charts/graphs" },
+      { value: "table", label: "Data table" },
+      { value: "activity", label: "Activity feed" },
+      { value: "sidebar", label: "Sidebar navigation" }
+    ],
+    initialValues: ["stats", "sidebar"]
+  });
+  if (p4.isCancel(components)) return originalInput;
+  return `Create a dashboard with:
+- Components: ${components.join(", ")}
+- Responsive layout
+- Loading skeletons
+- Empty states
+- Error boundaries
+- Follow all CodeBakers patterns`;
+}
+async function runAIWizard(originalInput) {
+  console.log(chalk5.cyan("\n\u{1F916} AI Feature Wizard"));
+  const aiType = await p4.select({
+    message: "What AI feature?",
+    options: [
+      { value: "chat", label: "\u{1F4AC} Chat interface" },
+      { value: "generate", label: "\u{1F4DD} Content generation" },
+      { value: "analyze", label: "\u{1F50D} Data analysis" }
+    ]
+  });
+  if (p4.isCancel(aiType)) return originalInput;
+  const streaming = await p4.confirm({
+    message: "Use streaming responses?",
+    initialValue: true
+  });
+  return `Create an AI ${aiType} feature with:
+- Streaming: ${streaming ? "Yes" : "No"}
+- Use Anthropic Claude API
+- Include conversation history
+- Loading indicators
+- Error handling
+- Stop generation button
+- Follow all CodeBakers patterns`;
+}
+async function handleSlashCommand(command, context, config) {
+  const [cmd, ...args2] = command.slice(1).split(" ");
+  switch (cmd.toLowerCase()) {
+    case "deploy":
+      console.log(chalk5.dim("Running deploy..."));
+      break;
+    case "check":
+      console.log(chalk5.dim("Running pattern check..."));
+      await runPatternCheck(false);
+      break;
+    case "status":
+      console.log(chalk5.cyan(`
+Project: ${context.name}
+Framework: ${context.framework}
+UI: ${context.ui}
+Files: ${context.existingFiles.length}
+`));
+      break;
+    case "undo":
+      console.log(chalk5.yellow("Undo not yet implemented"));
+      break;
+    case "help":
+      showHelp();
+      break;
+    default:
+      console.log(chalk5.dim(`Unknown command: ${cmd}`));
+  }
+}
+function showHelp() {
+  console.log(chalk5.cyan(`
+Available commands:
+
+  /deploy      Deploy to production
+  /check       Run pattern check
+  /status      Show project status
+  /undo        Undo last change
+  /help        Show this help
+
+Tips:
+  \u2022 Just describe what you want to build
+  \u2022 I'll ask clarifying questions if needed
+  \u2022 All code follows your CodeBakers patterns
+  \u2022 Patterns are auto-checked after every change
+`));
+}
+async function autoFixViolations(violations, anthropic, systemPrompt) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    if (!byFile.has(v.file)) {
+      byFile.set(v.file, []);
+    }
+    byFile.get(v.file).push(v);
+  }
+  for (const [file, fileViolations] of byFile) {
+    const content = await fs5.readFile(path5.join(process.cwd(), file), "utf-8");
+    const fixPrompt = `Fix these violations in ${file}:
+
+${fileViolations.map((v) => `- ${v.rule}: ${v.message}`).join("\n")}
+
+Current file content:
+\`\`\`
+${content}
+\`\`\`
+
+Output only the fixed file content, no explanation.`;
+    const response = await anthropic.messages.create({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 8192,
+      system: systemPrompt,
+      messages: [{ role: "user", content: fixPrompt }]
+    });
+    const fixedContent = response.content[0].type === "text" ? response.content[0].text : "";
+    const codeMatch = fixedContent.match(/```(?:tsx?|jsx?)?\n([\s\S]+?)\n```/);
+    const finalContent = codeMatch ? codeMatch[1] : fixedContent;
+    await fs5.writeFile(path5.join(process.cwd(), file), finalContent);
+  }
+}
+
+// src/commands/deploy.ts
+import * as p5 from "@clack/prompts";
+import chalk6 from "chalk";
+import { execa as execa4 } from "execa";
+import * as fs6 from "fs-extra";
+import * as path6 from "path";
+import Anthropic2 from "@anthropic-ai/sdk";
+async function deployCommand(options = {}) {
+  const config = new Config();
+  if (!config.isInProject()) {
+    p5.log.error("Not in a CodeBakers project.");
+    return;
+  }
+  p5.intro(chalk6.bgCyan.black(" Deploy to Production "));
+  const spinner11 = p5.spinner();
+  if (options.check !== false) {
+    spinner11.start("Running CodeBakers check...");
+    const checkResult = await runPatternCheck(false);
+    if (!checkResult.passed) {
+      spinner11.stop("");
+      const errors = checkResult.violations.filter((v) => v.severity === "error");
+      if (errors.length > 0) {
+        p5.log.error(`${errors.length} pattern violations found. Fix before deploying.`);
+        const showViolations = await p5.confirm({
+          message: "Show violations?",
+          initialValue: true
+        });
+        if (showViolations && !p5.isCancel(showViolations)) {
+          for (const v of errors) {
+            console.log(chalk6.red(`  \u2717 ${v.file}:${v.line} - ${v.message}`));
+          }
+        }
+        const autoFix2 = await p5.confirm({
+          message: "Attempt auto-fix with AI?",
+          initialValue: true
+        });
+        if (!autoFix2 || p5.isCancel(autoFix2)) {
+          p5.outro(chalk6.red("Deploy cancelled."));
+          return;
+        }
+        spinner11.start("Auto-fixing with AI...");
+        await autoFixWithAI(config, errors);
+        spinner11.stop("Auto-fix complete");
+        const recheck = await runPatternCheck(false);
+        if (!recheck.passed) {
+          p5.log.error("Some violations remain. Manual fix required.");
+          p5.outro(chalk6.red("Deploy cancelled."));
+          return;
+        }
+      }
+    }
+    spinner11.stop("Pattern check passed");
+  }
+  spinner11.start("Running TypeScript check...");
+  try {
+    await execa4("npx", ["tsc", "--noEmit"], { cwd: process.cwd() });
+    spinner11.stop("TypeScript check passed");
+  } catch (error) {
+    spinner11.stop("");
+    p5.log.error("TypeScript errors found.");
+    const fix = await p5.confirm({
+      message: "Attempt to fix TypeScript errors?",
+      initialValue: true
+    });
+    if (fix && !p5.isCancel(fix)) {
+      spinner11.start("Fixing TypeScript errors...");
+      const fixed = await fixTypeScriptErrors(config);
+      spinner11.stop(fixed ? "TypeScript errors fixed" : "Could not auto-fix all errors");
+      if (!fixed) {
+        p5.outro(chalk6.red("Deploy cancelled."));
+        return;
+      }
+    } else {
+      p5.outro(chalk6.red("Deploy cancelled."));
+      return;
+    }
+  }
+  spinner11.start("Building project...");
+  try {
+    await execa4("pnpm", ["build"], { cwd: process.cwd() });
+    spinner11.stop("Build successful");
+  } catch (error) {
+    spinner11.stop("");
+    p5.log.error("Build failed.");
+    const errorOutput = error instanceof Error ? error.message : "Unknown error";
+    console.log(chalk6.dim(errorOutput));
+    const fix = await p5.confirm({
+      message: "Attempt to fix build errors with AI?",
+      initialValue: true
+    });
+    if (fix && !p5.isCancel(fix)) {
+      spinner11.start("Fixing build errors...");
+      const fixed = await fixBuildErrors(config, errorOutput);
+      spinner11.stop(fixed ? "Build errors fixed" : "Could not auto-fix");
+      if (fixed) {
+        spinner11.start("Retrying build...");
+        try {
+          await execa4("pnpm", ["build"], { cwd: process.cwd() });
+          spinner11.stop("Build successful");
+        } catch {
+          spinner11.stop("Build still failing");
+          p5.outro(chalk6.red("Deploy cancelled."));
+          return;
+        }
+      } else {
+        p5.outro(chalk6.red("Deploy cancelled."));
+        return;
+      }
+    } else {
+      p5.outro(chalk6.red("Deploy cancelled."));
+      return;
+    }
+  }
+  spinner11.start("Checking for uncommitted changes...");
+  const { stdout: gitStatus } = await execa4("git", ["status", "--porcelain"], { cwd: process.cwd() });
+  if (gitStatus.trim()) {
+    spinner11.stop("");
+    const commit = await p5.confirm({
+      message: "You have uncommitted changes. Commit before deploying?",
+      initialValue: true
+    });
+    if (commit && !p5.isCancel(commit)) {
+      const message = await p5.text({
+        message: "Commit message:",
+        placeholder: "Pre-deploy changes",
+        initialValue: "Pre-deploy changes"
+      });
+      if (!p5.isCancel(message)) {
+        await execa4("git", ["add", "."], { cwd: process.cwd() });
+        await execa4("git", ["commit", "-m", message], { cwd: process.cwd() });
+        spinner11.start("Pushing to GitHub...");
+        await execa4("git", ["push"], { cwd: process.cwd() });
+        spinner11.stop("Pushed to GitHub");
+      }
+    }
+  } else {
+    spinner11.stop("No uncommitted changes");
+  }
+  const deployType = options.preview ? "preview" : "production";
+  spinner11.start(`Deploying to ${deployType}...`);
+  try {
+    const vercel = new VercelService(config);
+    const deployment = await vercel.deploy(process.cwd(), !options.preview);
+    spinner11.stop("Deployment complete!");
+    console.log(boxedOutput(`
+${chalk6.green("\u2713")} Deployed successfully!
+
+${chalk6.bold("URL:")} ${deployment.url}
+${chalk6.bold("Type:")} ${deployType}
+${chalk6.bold("Time:")} ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}
+
+${chalk6.dim("View in Vercel Dashboard:")}
+${chalk6.dim(deployment.dashboardUrl || "https://vercel.com/dashboard")}
+`));
+  } catch (error) {
+    spinner11.stop("");
+    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    p5.log.error(`Deployment failed: ${errorMsg}`);
+    if (errorMsg.includes("Build failed")) {
+      const retry = await p5.confirm({
+        message: "Attempt to fix and retry?",
+        initialValue: true
+      });
+      if (retry && !p5.isCancel(retry)) {
+        spinner11.start("Analyzing Vercel build error...");
+        spinner11.stop("Fix attempted");
+      }
+    }
+    p5.outro(chalk6.red("Deploy failed."));
+  }
+}
+async function autoFixWithAI(config, violations) {
+  const anthropicCreds = config.getCredentials("anthropic");
+  if (!anthropicCreds?.apiKey) {
+    throw new Error("Anthropic API key not configured");
+  }
+  const anthropic = new Anthropic2({
+    apiKey: anthropicCreds.apiKey
+  });
+  const byFile = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    if (!byFile.has(v.file)) {
+      byFile.set(v.file, []);
+    }
+    byFile.get(v.file).push(v);
+  }
+  for (const [file, fileViolations] of byFile) {
+    const filePath = path6.join(process.cwd(), file);
+    const content = await fs6.readFile(filePath, "utf-8");
+    const prompt = `Fix these CodeBakers pattern violations in this file:
+
+Violations:
+${fileViolations.map((v) => `- Line ${v.line}: ${v.rule} - ${v.message}`).join("\n")}
+
+Current file content:
+\`\`\`typescript
+${content}
+\`\`\`
+
+Output ONLY the corrected file content, no explanations. Keep all existing functionality.`;
+    const response = await anthropic.messages.create({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 8192,
+      messages: [{ role: "user", content: prompt }]
+    });
+    let fixed = response.content[0].type === "text" ? response.content[0].text : "";
+    const codeMatch = fixed.match(/```(?:typescript|tsx?)?\n([\s\S]+?)\n```/);
+    if (codeMatch) {
+      fixed = codeMatch[1];
+    }
+    await fs6.writeFile(filePath, fixed);
+  }
+}
+async function fixTypeScriptErrors(config) {
+  try {
+    const { stderr } = await execa4("npx", ["tsc", "--noEmit"], {
+      cwd: process.cwd(),
+      reject: false
+    });
+    if (!stderr) return true;
+    const anthropicCreds = config.getCredentials("anthropic");
+    if (!anthropicCreds?.apiKey) {
+      return false;
+    }
+    const anthropic = new Anthropic2({
+      apiKey: anthropicCreds.apiKey
+    });
+    const errorLines = stderr.split("\n").filter((line) => line.includes("error TS"));
+    for (const errorLine of errorLines.slice(0, 10)) {
+      const match = errorLine.match(/^(.+?)\((\d+),(\d+)\): error (TS\d+): (.+)$/);
+      if (!match) continue;
+      const [, file, line, , , message] = match;
+      const filePath = path6.join(process.cwd(), file);
+      if (!await fs6.pathExists(filePath)) continue;
+      const content = await fs6.readFile(filePath, "utf-8");
+      const prompt = `Fix this TypeScript error:
+
+File: ${file}
+Line: ${line}
+Error: ${message}
+
+Current file content:
+\`\`\`typescript
+${content}
+\`\`\`
+
+Output ONLY the corrected file content, no explanations.`;
+      const response = await anthropic.messages.create({
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 8192,
+        messages: [{ role: "user", content: prompt }]
+      });
+      let fixed = response.content[0].type === "text" ? response.content[0].text : "";
+      const codeMatch = fixed.match(/```(?:typescript|tsx?)?\n([\s\S]+?)\n```/);
+      if (codeMatch) {
+        fixed = codeMatch[1];
+      }
+      await fs6.writeFile(filePath, fixed);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function fixBuildErrors(config, errorOutput) {
+  const anthropicCreds = config.getCredentials("anthropic");
+  if (!anthropicCreds?.apiKey) {
+    return false;
+  }
+  const anthropic = new Anthropic2({
+    apiKey: anthropicCreds.apiKey
+  });
+  const fileMatch = errorOutput.match(/(?:Error|error).*?(?:in|at)\s+(.+?\.tsx?)(?::|$)/);
+  if (!fileMatch) return false;
+  const file = fileMatch[1];
+  const filePath = path6.join(process.cwd(), file);
+  if (!await fs6.pathExists(filePath)) return false;
+  const content = await fs6.readFile(filePath, "utf-8");
+  const prompt = `Fix this build error:
+
+Error output:
+${errorOutput}
+
+File: ${file}
+
+Current file content:
+\`\`\`typescript
+${content}
+\`\`\`
+
+Output ONLY the corrected file content, no explanations.`;
+  try {
+    const response = await anthropic.messages.create({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 8192,
+      messages: [{ role: "user", content: prompt }]
+    });
+    let fixed = response.content[0].type === "text" ? response.content[0].text : "";
+    const codeMatch = fixed.match(/```(?:typescript|tsx?)?\n([\s\S]+?)\n```/);
+    if (codeMatch) {
+      fixed = codeMatch[1];
+    }
+    await fs6.writeFile(filePath, fixed);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function boxedOutput(content) {
+  const lines = content.split("\n");
+  const maxLength = Math.max(...lines.map((l) => l.replace(/\x1b\[[0-9;]*m/g, "").length));
+  const border = "\u2500".repeat(maxLength + 2);
+  return `
+\u256D${border}\u256E
+${lines.map((l) => `\u2502 ${l.padEnd(maxLength)} \u2502`).join("\n")}
+\u2570${border}\u256F`;
+}
+
+// src/commands/connect.ts
+async function connectCommand(service) {
+  const config = new Config();
+  await setupCommand();
+}
+
+// src/commands/status.ts
+import * as p6 from "@clack/prompts";
+import chalk7 from "chalk";
+import * as fs7 from "fs-extra";
+import * as path7 from "path";
+async function statusCommand() {
+  const config = new Config();
+  const cwd = process.cwd();
+  p6.intro(chalk7.bgCyan.black(" Project Status "));
+  if (!config.isInProject()) {
+    const projects = config.getProjects();
+    if (projects.length === 0) {
+      p6.log.info("No projects found. Run `codebakers init` to create one.");
+      return;
+    }
+    console.log(chalk7.bold("\nYour Projects:\n"));
+    for (const project of projects) {
+      const exists = await fs7.pathExists(project.path);
+      const status = exists ? chalk7.green("\u2713") : chalk7.red("\u2717");
+      console.log(`  ${status} ${project.name}`);
+      console.log(chalk7.dim(`     ${project.path}`));
+      console.log("");
+    }
+    return;
+  }
+  const projectConfig = await fs7.readJson(
+    path7.join(cwd, ".codebakers", "config.json")
+  ).catch(() => ({}));
+  const packageJson = await fs7.readJson(
+    path7.join(cwd, "package.json")
+  ).catch(() => ({}));
+  console.log(`
+${chalk7.bold("Project:")} ${packageJson.name || path7.basename(cwd)}
+${chalk7.bold("Framework:")} ${projectConfig.framework || "unknown"}
+${chalk7.bold("UI:")} ${projectConfig.ui || "unknown"}
+
+${chalk7.bold("Quick Actions:")}
+  ${chalk7.cyan("codebakers code")}   \u2014 AI coding agent
+  ${chalk7.cyan("codebakers check")}  \u2014 Pattern enforcement  
+  ${chalk7.cyan("codebakers deploy")} \u2014 Deploy to production
+`);
+  p6.outro("");
+}
+
+// src/commands/gateway.ts
+import * as p7 from "@clack/prompts";
+import chalk8 from "chalk";
+async function gatewayCommand(options = {}) {
+  const config = new Config();
+  p7.intro(chalk8.bgCyan.black(" Channel Gateway "));
+  if (options.start) {
+    await startAllChannels(config);
+    return;
+  }
+  if (options.stop) {
+    await stopAllChannels(config);
+    return;
+  }
+  if (options.status) {
+    await showGatewayStatus(config);
+    return;
+  }
+  const action = await p7.select({
+    message: "What do you want to do?",
+    options: [
+      { value: "status", label: "\u{1F4CA} View status", hint: "see all channels" },
+      { value: "connect", label: "\u{1F517} Connect channel", hint: "add WhatsApp, Telegram, etc." },
+      { value: "start", label: "\u25B6\uFE0F  Start gateway", hint: "start receiving messages" },
+      { value: "stop", label: "\u23F9\uFE0F  Stop gateway", hint: "pause all channels" },
+      { value: "deploy", label: "\u{1F680} Deploy to cloud", hint: "always-on hosting" },
+      { value: "back", label: "\u2190 Back" }
+    ]
+  });
+  if (p7.isCancel(action) || action === "back") {
+    return;
+  }
+  switch (action) {
+    case "status":
+      await showGatewayStatus(config);
+      break;
+    case "connect":
+      await connectChannelWizard(config);
+      break;
+    case "start":
+      await startAllChannels(config);
+      break;
+    case "stop":
+      await stopAllChannels(config);
+      break;
+    case "deploy":
+      await deployGatewayWizard(config);
+      break;
+  }
+}
+async function showGatewayStatus(config) {
+  const channels = await getChannelStatuses(config);
+  console.log(chalk8.bold("\n\u{1F4F1} Channel Gateway Status\n"));
+  for (const channel of channels) {
+    const statusIcon = {
+      running: chalk8.green("\u25CF"),
+      stopped: chalk8.gray("\u25CB"),
+      error: chalk8.red("\u2717"),
+      connecting: chalk8.yellow("\u25D0")
+    }[channel.status];
+    const statusText = {
+      running: chalk8.green("Running"),
+      stopped: chalk8.gray("Stopped"),
+      error: chalk8.red("Error"),
+      connecting: chalk8.yellow("Connecting...")
+    }[channel.status];
+    console.log(`  ${channel.icon} ${channel.name.padEnd(15)} ${statusIcon} ${statusText}`);
+  }
+  console.log("");
+}
+async function getChannelStatuses(config) {
+  const channels = [
+    {
+      id: "whatsapp",
+      name: "WhatsApp",
+      description: "WhatsApp via Baileys",
+      icon: "\u{1F4AC}",
+      connected: !!config.getChannelConfig("whatsapp")?.enabled,
+      status: config.getChannelConfig("whatsapp")?.enabled ? "stopped" : "stopped"
+    },
+    {
+      id: "telegram",
+      name: "Telegram",
+      description: "Telegram Bot API",
+      icon: "\u2708\uFE0F",
+      connected: !!config.getChannelConfig("telegram")?.enabled,
+      status: config.getChannelConfig("telegram")?.enabled ? "stopped" : "stopped"
+    },
+    {
+      id: "discord",
+      name: "Discord",
+      description: "Discord.js bot",
+      icon: "\u{1F3AE}",
+      connected: !!config.getChannelConfig("discord")?.enabled,
+      status: config.getChannelConfig("discord")?.enabled ? "stopped" : "stopped"
+    },
+    {
+      id: "slack",
+      name: "Slack",
+      description: "Slack Bot API",
+      icon: "\u{1F4BC}",
+      connected: !!config.getChannelConfig("slack")?.enabled,
+      status: config.getChannelConfig("slack")?.enabled ? "stopped" : "stopped"
+    },
+    {
+      id: "sms",
+      name: "SMS",
+      description: "Twilio SMS",
+      icon: "\u{1F4F1}",
+      connected: !!config.getCredentials("twilio")?.accountSid,
+      status: config.getCredentials("twilio")?.accountSid ? "stopped" : "stopped"
+    }
+  ];
+  return channels;
+}
+async function connectChannelWizard(config) {
+  const channel = await p7.select({
+    message: "Which channel do you want to connect?",
+    options: [
+      { value: "whatsapp", label: "\u{1F4AC} WhatsApp", hint: "Personal or Business" },
+      { value: "telegram", label: "\u2708\uFE0F  Telegram", hint: "Create a bot" },
+      { value: "discord", label: "\u{1F3AE} Discord", hint: "Server bot" },
+      { value: "slack", label: "\u{1F4BC} Slack", hint: "Workspace app" },
+      { value: "sms", label: "\u{1F4F1} SMS", hint: "via Twilio" },
+      { value: "imessage", label: "\u{1F34E} iMessage", hint: "Mac only" }
+    ]
+  });
+  if (p7.isCancel(channel)) return;
+  switch (channel) {
+    case "whatsapp":
+      await connectWhatsApp(config);
+      break;
+    case "telegram":
+      await connectTelegram(config);
+      break;
+    case "discord":
+      await connectDiscord(config);
+      break;
+    case "slack":
+      await connectSlack(config);
+      break;
+    case "sms":
+      await connectSMS(config);
+      break;
+    case "imessage":
+      await connectiMessage(config);
+      break;
+  }
+}
+async function connectWhatsApp(config) {
+  p7.log.info(chalk8.bold("WhatsApp Setup"));
+  p7.log.info(chalk8.dim(`
+WhatsApp uses QR code authentication via Baileys library.
+Your phone needs to scan a QR code to connect.
+
+Note: This is for personal accounts. For WhatsApp Business API,
+you'll need a Meta Business account.
+`));
+  const proceed = await p7.confirm({
+    message: "Ready to scan QR code?",
+    initialValue: true
+  });
+  if (!proceed || p7.isCancel(proceed)) return;
+  const spinner11 = p7.spinner();
+  spinner11.start("Generating QR code...");
+  try {
+    spinner11.stop("");
+    console.log(chalk8.cyan(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                    \u2551
+\u2551   \u2584\u2584\u2584\u2584\u2584\u2584\u2584 \u2584\u2584\u2584\u2584\u2584 \u2584\u2584\u2584\u2584\u2584\u2584\u2584           \u2551
+\u2551   \u2588 \u2584\u2584\u2584 \u2588 \u2580\u2588\u2580\u2584\u2588 \u2588 \u2584\u2584\u2584 \u2588           \u2551
+\u2551   \u2588 \u2588\u2588\u2588 \u2588 \u2584\u2580 \u2580\u2584 \u2588 \u2588\u2588\u2588 \u2588           \u2551
+\u2551   \u2588\u2584\u2584\u2584\u2584\u2584\u2588 \u2588 \u2584\u2580\u2588 \u2588\u2584\u2584\u2584\u2584\u2584\u2588           \u2551
+\u2551   \u2584\u2584\u2584\u2584\u2584 \u2584\u2584\u2584\u2588\u2588\u2580\u2580\u2584 \u2584 \u2584 \u2584            \u2551
+\u2551   \u2588\u2588\u2580\u2580\u2580\u2584\u2584\u2580\u2584\u2580\u2584\u2584\u2588\u2580\u2588\u2588\u2580\u2584\u2588\u2584\u2584           \u2551
+\u2551   \u2584\u2584\u2584\u2584\u2584\u2584\u2584 \u2588\u2584\u2580\u2584\u2580 \u2584\u2588\u2588\u2584\u2588\u2584            \u2551
+\u2551   \u2588 \u2584\u2584\u2584 \u2588  \u2588\u2580\u2580\u2584\u2584\u2584\u2584\u2580\u2584               \u2551
+\u2551   \u2588 \u2588\u2588\u2588 \u2588 \u2584\u2588\u2588\u2588\u2584\u2588\u2580\u2588\u2584\u2584\u2584\u2588            \u2551
+\u2551   \u2588\u2584\u2584\u2584\u2584\u2584\u2588 \u2588\u2588\u2580\u2584\u2580\u2580\u2584\u2588\u2584\u2580\u2588             \u2551
+\u2551                                    \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+
+Scan this QR code with WhatsApp:
+1. Open WhatsApp on your phone
+2. Go to Settings > Linked Devices
+3. Tap "Link a Device"
+4. Scan the QR code above
+`));
+    const connected = await p7.confirm({
+      message: "Did you scan the QR code successfully?",
+      initialValue: false
+    });
+    if (connected && !p7.isCancel(connected)) {
+      config.setChannelConfig("whatsapp", { enabled: true });
+      p7.log.success("WhatsApp connected!");
+    }
+  } catch (error) {
+    spinner11.stop("Error connecting WhatsApp");
+    p7.log.error(error instanceof Error ? error.message : "Unknown error");
+  }
+}
+async function connectTelegram(config) {
+  p7.log.info(chalk8.bold("Telegram Bot Setup"));
+  p7.log.info(chalk8.dim(`
+To create a Telegram bot:
+1. Open Telegram and search for @BotFather
+2. Send /newbot
+3. Follow the prompts to name your bot
+4. Copy the API token
+`));
+  const openBotFather = await p7.confirm({
+    message: "Open BotFather in browser?",
+    initialValue: true
+  });
+  if (openBotFather && !p7.isCancel(openBotFather)) {
+    const open2 = (await import("open")).default;
+    await open2("https://t.me/botfather");
+  }
+  const token = await p7.text({
+    message: "Paste your bot token:",
+    placeholder: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11",
+    validate: (value) => {
+      if (!value) return "Token is required";
+      if (!value.includes(":")) return "Invalid token format";
+      return void 0;
+    }
+  });
+  if (p7.isCancel(token)) return;
+  const spinner11 = p7.spinner();
+  spinner11.start("Verifying bot token...");
+  try {
+    const response = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+    const data = await response.json();
+    if (!data.ok) {
+      throw new Error(data.description || "Invalid token");
+    }
+    spinner11.stop("Bot verified!");
+    config.setChannelConfig("telegram", {
+      enabled: true,
+      botToken: token,
+      botUsername: data.result.username
+    });
+    p7.log.success(`Connected to @${data.result.username}`);
+  } catch (error) {
+    spinner11.stop("Verification failed");
+    p7.log.error(error instanceof Error ? error.message : "Invalid token");
+  }
+}
+async function connectDiscord(config) {
+  p7.log.info(chalk8.bold("Discord Bot Setup"));
+  p7.log.info(chalk8.dim(`
+To create a Discord bot:
+1. Go to Discord Developer Portal
+2. Create a new application
+3. Go to Bot section
+4. Create a bot and copy the token
+5. Enable necessary intents (Message Content)
+`));
+  const openPortal = await p7.confirm({
+    message: "Open Discord Developer Portal?",
+    initialValue: true
+  });
+  if (openPortal && !p7.isCancel(openPortal)) {
+    const open2 = (await import("open")).default;
+    await open2("https://discord.com/developers/applications");
+  }
+  const token = await p7.text({
+    message: "Paste your bot token:",
+    placeholder: "MTIzNDU2Nzg5MDEyMzQ1Njc4.Gg1234.abc..."
+  });
+  if (p7.isCancel(token) || !token) return;
+  const clientId = await p7.text({
+    message: "Paste your application (client) ID:",
+    placeholder: "123456789012345678"
+  });
+  if (p7.isCancel(clientId) || !clientId) return;
+  config.setChannelConfig("discord", {
+    enabled: true,
+    botToken: token,
+    clientId
+  });
+  const inviteUrl = `https://discord.com/api/oauth2/authorize?client_id=${clientId}&permissions=2048&scope=bot`;
+  p7.log.success("Discord bot configured!");
+  p7.log.info(`Add bot to server: ${inviteUrl}`);
+}
+async function connectSlack(config) {
+  p7.log.info(chalk8.bold("Slack App Setup"));
+  p7.log.info(chalk8.dim(`
+To create a Slack app:
+1. Go to Slack API portal
+2. Create a new app
+3. Add bot scopes (chat:write, app_mentions:read, etc.)
+4. Install to workspace
+5. Copy the Bot Token
+`));
+  const openSlack = await p7.confirm({
+    message: "Open Slack API portal?",
+    initialValue: true
+  });
+  if (openSlack && !p7.isCancel(openSlack)) {
+    const open2 = (await import("open")).default;
+    await open2("https://api.slack.com/apps");
+  }
+  const token = await p7.text({
+    message: "Paste your Bot User OAuth Token:",
+    placeholder: "xoxb-...",
+    validate: (value) => {
+      if (!value) return "Token is required";
+      if (!value.startsWith("xoxb-")) return "Should start with xoxb-";
+      return void 0;
+    }
+  });
+  if (p7.isCancel(token)) return;
+  config.setChannelConfig("slack", {
+    enabled: true,
+    botToken: token
+  });
+  p7.log.success("Slack app configured!");
+}
+async function connectSMS(config) {
+  p7.log.info(chalk8.bold("SMS via Twilio"));
+  const twilioConfig = config.getCredentials("twilio");
+  if (twilioConfig?.accountSid) {
+    p7.log.info("Twilio is already configured.");
+    const reconfigure = await p7.confirm({
+      message: "Reconfigure Twilio?",
+      initialValue: false
+    });
+    if (!reconfigure || p7.isCancel(reconfigure)) {
+      config.setChannelConfig("sms", { enabled: true });
+      p7.log.success("SMS channel enabled!");
+      return;
+    }
+  }
+  const openTwilio = await p7.confirm({
+    message: "Open Twilio Console?",
+    initialValue: true
+  });
+  if (openTwilio && !p7.isCancel(openTwilio)) {
+    const open2 = (await import("open")).default;
+    await open2("https://console.twilio.com/");
+  }
+  const accountSid = await p7.text({
+    message: "Account SID:",
+    placeholder: "AC..."
+  });
+  if (p7.isCancel(accountSid)) return;
+  const authToken = await p7.text({
+    message: "Auth Token:",
+    placeholder: "..."
+  });
+  if (p7.isCancel(authToken)) return;
+  const phoneNumber = await p7.text({
+    message: "Twilio phone number:",
+    placeholder: "+1234567890"
+  });
+  if (p7.isCancel(phoneNumber)) return;
+  config.setCredentials("twilio", {
+    accountSid,
+    authToken,
+    phoneNumber
+  });
+  config.setChannelConfig("sms", { enabled: true });
+  p7.log.success("SMS channel configured!");
+}
+async function connectiMessage(config) {
+  p7.log.warn("iMessage support requires macOS and additional setup.");
+  p7.log.info(chalk8.dim(`
+iMessage integration uses AppleScript on macOS.
+This requires:
+1. macOS with Messages app
+2. iCloud signed in
+3. Terminal with accessibility permissions
+`));
+  const isMac = process.platform === "darwin";
+  if (!isMac) {
+    p7.log.error("iMessage is only available on macOS.");
+    return;
+  }
+  p7.log.info("iMessage support coming soon.");
+}
+async function startAllChannels(config) {
+  const spinner11 = p7.spinner();
+  spinner11.start("Starting channel gateway...");
+  await new Promise((resolve) => setTimeout(resolve, 1e3));
+  spinner11.stop("Gateway started");
+  console.log(chalk8.green(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551  Gateway is running!                  \u2551
+\u2551                                       \u2551
+\u2551  You can now receive messages from:   \u2551
+\u2551  \u2022 WhatsApp  \u2022 Telegram  \u2022 Discord    \u2551
+\u2551  \u2022 Slack     \u2022 SMS                    \u2551
+\u2551                                       \u2551
+\u2551  Press Ctrl+C to stop                 \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`));
+}
+async function stopAllChannels(config) {
+  const spinner11 = p7.spinner();
+  spinner11.start("Stopping gateway...");
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  spinner11.stop("Gateway stopped");
+}
+async function deployGatewayWizard(config) {
+  p7.log.info(chalk8.bold("Deploy Gateway to Cloud"));
+  const platform = await p7.select({
+    message: "Where do you want to deploy?",
+    options: [
+      { value: "codebakers", label: "\u2601\uFE0F  CodeBakers Cloud", hint: "$29/mo - We handle everything" },
+      { value: "vps", label: "\u{1F5A5}\uFE0F  VPS", hint: "$5/mo - DigitalOcean, etc." },
+      { value: "local", label: "\u{1F3E0} Home server", hint: "Raspberry Pi, etc." }
+    ]
+  });
+  if (p7.isCancel(platform)) return;
+  switch (platform) {
+    case "codebakers":
+      p7.log.info("CodeBakers Cloud coming soon!");
+      p7.log.info(chalk8.dim("Sign up at https://codebakers.dev/cloud"));
+      break;
+    case "vps":
+      await deployToVPS(config);
+      break;
+    case "local":
+      p7.log.info("Local deployment guide:");
+      p7.log.info(chalk8.dim(`
+1. Install Node.js on your server
+2. Clone your project
+3. Run: npm install
+4. Run: pm2 start codebakers -- gateway --start
+5. Configure firewall to allow outbound connections
+`));
+      break;
+  }
+}
+async function deployToVPS(config) {
+  const provider = await p7.select({
+    message: "Which VPS provider?",
+    options: [
+      { value: "digitalocean", label: "DigitalOcean" },
+      { value: "vultr", label: "Vultr" },
+      { value: "linode", label: "Linode" },
+      { value: "hetzner", label: "Hetzner" },
+      { value: "other", label: "Other" }
+    ]
+  });
+  if (p7.isCancel(provider)) return;
+  if (provider === "digitalocean") {
+    p7.log.info("DigitalOcean auto-deploy:");
+    p7.log.info(chalk8.dim(`
+1. Opening DigitalOcean login...
+2. We'll create a $6/mo droplet
+3. Install CodeBakers gateway
+4. Connect all your channels
+`));
+    const proceed = await p7.confirm({
+      message: "Open DigitalOcean?",
+      initialValue: true
+    });
+    if (proceed && !p7.isCancel(proceed)) {
+      const open2 = (await import("open")).default;
+      await open2("https://cloud.digitalocean.com/");
+    }
+  } else {
+    p7.log.info(chalk8.dim(`
+Manual VPS setup:
+
+1. Create a VPS (Ubuntu 22.04 recommended)
+2. SSH into your server
+3. Run these commands:
+
+   curl -fsSL https://codebakers.dev/install.sh | bash
+   codebakers gateway --start
+
+4. Your gateway will start automatically on boot
+`));
+  }
+}
+
+// src/commands/learn.ts
+import * as p8 from "@clack/prompts";
+import chalk9 from "chalk";
+async function learnCommand() {
+  const config = new Config();
+  const learning = config.getLearning();
+  p8.intro(chalk9.bgCyan.black(" Learning Settings "));
+  console.log(chalk9.bold("\n\u{1F9E0} What CodeBakers has learned about you:\n"));
+  const shortcuts = Object.entries(learning.shortcuts);
+  if (shortcuts.length > 0) {
+    console.log(chalk9.bold("Shortcuts:"));
+    for (const [short, full] of shortcuts) {
+      console.log(`  ${chalk9.cyan(short)} \u2192 ${full}`);
+    }
+    console.log("");
+  }
+  const prefs = Object.entries(learning.preferences);
+  if (prefs.length > 0) {
+    console.log(chalk9.bold("Preferences:"));
+    for (const [key, value] of prefs) {
+      console.log(`  ${key}: ${chalk9.cyan(String(value))}`);
+    }
+    console.log("");
+  }
+  if (shortcuts.length === 0 && prefs.length === 0) {
+    console.log(chalk9.dim("  Nothing learned yet. Use CodeBakers more!\n"));
+  }
+  p8.outro("");
+}
+
+// src/commands/security.ts
+import * as p9 from "@clack/prompts";
+import chalk10 from "chalk";
+import * as fs8 from "fs-extra";
+import glob2 from "fast-glob";
+import * as path8 from "path";
+async function securityCommand() {
+  p9.intro(chalk10.bgCyan.black(" Security Audit "));
+  const spinner11 = p9.spinner();
+  spinner11.start("Scanning for security issues...");
+  const issues = await runSecurityScan();
+  spinner11.stop("Scan complete");
+  if (issues.length === 0) {
+    console.log(chalk10.green("\n\u2713 No security issues found!\n"));
+    displaySecurityScore(100);
+  } else {
+    console.log(chalk10.yellow(`
+\u26A0\uFE0F  ${issues.length} security issues found:
+`));
+    for (const issue of issues) {
+      const icon = issue.severity === "critical" ? chalk10.red("\u{1F534}") : issue.severity === "high" ? chalk10.red("\u{1F7E0}") : chalk10.yellow("\u{1F7E1}");
+      console.log(`${icon} ${chalk10.bold(issue.title)}`);
+      console.log(chalk10.dim(`   ${issue.file}:${issue.line}`));
+      console.log(`   ${issue.description}
+`);
+    }
+    const score = Math.max(0, 100 - issues.filter((i) => i.severity === "critical").length * 30 - issues.filter((i) => i.severity === "high").length * 15);
+    displaySecurityScore(score);
+  }
+  p9.outro("");
+}
+async function runSecurityScan() {
+  const cwd = process.cwd();
+  const issues = [];
+  const files = await glob2(["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",
+      description: "Stripe API key should be in environment variables"
+    },
+    {
+      pattern: /\beval\s*\(/g,
+      title: "Use of eval()",
+      severity: "critical",
+      description: "eval() is a security vulnerability"
+    },
+    {
+      pattern: /dangerouslySetInnerHTML/g,
+      title: "dangerouslySetInnerHTML",
+      severity: "high",
+      description: "Ensure content is sanitized with DOMPurify"
+    }
+  ];
+  for (const file of files) {
+    const content = await fs8.readFile(path8.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) {
+  const color = score >= 80 ? chalk10.green : score >= 50 ? chalk10.yellow : chalk10.red;
+  const grade = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : "F";
+  console.log(chalk10.bold("Security Score:"));
+  console.log(color(`
+  ${score}/100  Grade: ${grade}
+`));
+}
+
+// src/commands/generate.ts
+import * as p10 from "@clack/prompts";
+import chalk11 from "chalk";
+import * as fs9 from "fs-extra";
+import * as path9 from "path";
+async function generateCommand(type) {
+  p10.intro(chalk11.bgCyan.black(" Generate "));
+  const generateType = type || await p10.select({
+    message: "What do you want to generate?",
+    options: [
+      { value: "component", label: "\u{1F9E9} Component" },
+      { value: "page", label: "\u{1F4C4} Page" },
+      { value: "api", label: "\u{1F50C} API Route" },
+      { value: "hook", label: "\u{1FA9D} Custom Hook" },
+      { value: "store", label: "\u{1F4E6} Zustand Store" },
+      { value: "form", label: "\u{1F4DD} Form Component" }
+    ]
+  });
+  if (p10.isCancel(generateType)) return;
+  const name = await p10.text({
+    message: "Name:",
+    placeholder: generateType === "page" ? "dashboard" : "MyComponent",
+    validate: (v) => !v ? "Name is required" : void 0
+  });
+  if (p10.isCancel(name)) return;
+  const spinner11 = p10.spinner();
+  spinner11.start("Generating...");
+  await generateFile(generateType, name);
+  spinner11.stop(`Generated ${name}`);
+  p10.outro("");
+}
+async function generateFile(type, name) {
+  const cwd = process.cwd();
+  const templates = {
+    component: {
+      path: `src/components/${name}.tsx`,
+      content: `'use client';
+
+interface ${name}Props {
+  // props
+}
+
+export function ${name}({}: ${name}Props) {
+  return (
+    <div>
+      <h2>${name}</h2>
+    </div>
+  );
+}
+`
+    },
+    page: {
+      path: `src/app/${name}/page.tsx`,
+      content: `export default function ${name.charAt(0).toUpperCase() + name.slice(1)}Page() {
+  return (
+    <div className="container mx-auto py-8">
+      <h1 className="text-2xl font-bold">${name}</h1>
+    </div>
+  );
+}
+`
+    },
+    api: {
+      path: `src/app/api/${name}/route.ts`,
+      content: `import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(request: NextRequest) {
+  try {
+    return NextResponse.json({ data: [] });
+  } catch (error) {
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 });
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    return NextResponse.json({ success: true }, { status: 201 });
+  } catch (error) {
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 });
+  }
+}
+`
+    },
+    hook: {
+      path: `src/hooks/use-${name.toLowerCase()}.ts`,
+      content: `import { useState, useEffect } from 'react';
+
+export function use${name}() {
+  const [data, setData] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  return { data, isLoading, error };
+}
+`
+    },
+    store: {
+      path: `src/stores/${name.toLowerCase()}-store.ts`,
+      content: `import { create } from 'zustand';
+
+interface ${name}State {
+  items: unknown[];
+  isLoading: boolean;
+  setItems: (items: unknown[]) => void;
+  reset: () => void;
+}
+
+export const use${name}Store = create<${name}State>((set) => ({
+  items: [],
+  isLoading: false,
+  setItems: (items) => set({ items }),
+  reset: () => set({ items: [], isLoading: false }),
+}));
+`
+    },
+    form: {
+      path: `src/components/forms/${name}-form.tsx`,
+      content: `'use client';
+
+import { useState } from 'react';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+import { toast } from 'sonner';
+
+const schema = z.object({
+  name: z.string().min(1, 'Required'),
+});
+
+type FormData = z.infer<typeof schema>;
+
+export function ${name}Form({ onSuccess }: { onSuccess?: () => void }) {
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const form = useForm<FormData>({ resolver: zodResolver(schema) });
+
+  const onSubmit = async (data: FormData) => {
+    setIsSubmitting(true);
+    try {
+      // Submit
+      toast.success('Success!');
+      onSuccess?.();
+    } catch (error) {
+      toast.error('Failed');
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  return (
+    <form onSubmit={form.handleSubmit(onSubmit)}>
+      {/* Form fields */}
+      <button type="submit" disabled={isSubmitting}>
+        {isSubmitting ? 'Submitting...' : 'Submit'}
+      </button>
+    </form>
+  );
+}
+`
+    }
+  };
+  const template = templates[type];
+  if (!template) throw new Error(`Unknown type: ${type}`);
+  const filePath = path9.join(cwd, template.path);
+  await fs9.ensureDir(path9.dirname(filePath));
+  await fs9.writeFile(filePath, template.content);
+}
+
+// src/commands/fix.ts
+import * as p11 from "@clack/prompts";
+import chalk12 from "chalk";
+async function fixCommand() {
+  p11.intro(chalk12.bgCyan.black(" Auto-Fix "));
+  const spinner11 = p11.spinner();
+  spinner11.start("Analyzing code...");
+  const result = await runPatternCheck(true);
+  if (result.passed) {
+    spinner11.stop("No issues found!");
+  } else {
+    spinner11.stop(`Fixed ${result.violations.length} issues`);
+  }
+  p11.outro(chalk12.green("Done!"));
+}
+
+// src/commands/design.ts
+import * as p12 from "@clack/prompts";
+import chalk13 from "chalk";
+import * as fs10 from "fs-extra";
+import * as path10 from "path";
+var DESIGN_PROFILES = {
+  minimal: {
+    name: "Minimal",
+    inspiration: "Linear, Notion, Vercel",
+    fonts: { heading: "Inter", body: "Inter" },
+    corners: "rounded-md",
+    shadows: "none",
+    spacing: "generous"
+  },
+  bold: {
+    name: "Bold",
+    inspiration: "Stripe, Ramp, Mercury",
+    fonts: { heading: "Plus Jakarta Sans", body: "Inter" },
+    corners: "rounded-2xl",
+    shadows: "elevated",
+    spacing: "generous"
+  },
+  editorial: {
+    name: "Editorial",
+    inspiration: "Medium, Substack, NY Times",
+    fonts: { heading: "Playfair Display", body: "Source Serif Pro" },
+    corners: "rounded-none",
+    shadows: "none",
+    spacing: "reading"
+  },
+  playful: {
+    name: "Playful",
+    inspiration: "Figma, Slack, Notion",
+    fonts: { heading: "Nunito", body: "Nunito" },
+    corners: "rounded-full",
+    shadows: "soft",
+    spacing: "comfortable"
+  },
+  premium: {
+    name: "Premium",
+    inspiration: "Apple, Porsche, Amex",
+    fonts: { heading: "Cormorant Garamond", body: "Lato" },
+    corners: "rounded-lg",
+    shadows: "subtle",
+    spacing: "luxurious"
+  },
+  dashboard: {
+    name: "Dashboard",
+    inspiration: "Datadog, Grafana, Linear",
+    fonts: { heading: "Inter", body: "Inter" },
+    corners: "rounded-md",
+    shadows: "card",
+    spacing: "compact"
+  }
+};
+async function designCommand(subcommand) {
+  const config = new Config();
+  if (!config.isInProject()) {
+    p12.log.error("Not in a CodeBakers project. Run `codebakers init` first.");
+    return;
+  }
+  p12.intro(chalk13.bgCyan.black(" Design System "));
+  const action = subcommand || await p12.select({
+    message: "What do you want to do?",
+    options: [
+      { value: "profile", label: "\u{1F3A8} Set design profile" },
+      { value: "palette", label: "\u{1F308} Generate color palette" },
+      { value: "check", label: "\u2705 Check design quality" },
+      { value: "view", label: "\u{1F440} View current settings" }
+    ]
+  });
+  if (p12.isCancel(action)) return;
+  switch (action) {
+    case "profile":
+      await setProfile();
+      break;
+    case "palette":
+      await generatePalette();
+      break;
+    case "check":
+      await checkDesign();
+      break;
+    case "view":
+      await viewSettings();
+      break;
+  }
+}
+async function setProfile() {
+  const profile = await p12.select({
+    message: "Choose your design profile:",
+    options: Object.entries(DESIGN_PROFILES).map(([key, value]) => ({
+      value: key,
+      label: `${value.name}`,
+      hint: value.inspiration
+    }))
+  });
+  if (p12.isCancel(profile)) return;
+  const selected = DESIGN_PROFILES[profile];
+  const configPath = path10.join(process.cwd(), ".codebakers", "design.json");
+  await fs10.ensureDir(path10.dirname(configPath));
+  await fs10.writeJson(configPath, {
+    profile,
+    ...selected,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, { spaces: 2 });
+  p12.log.success(`Design profile set to ${selected.name}`);
+  console.log(chalk13.dim(`
+  Fonts:    ${selected.fonts.heading} / ${selected.fonts.body}
+  Corners:  ${selected.corners}
+  Shadows:  ${selected.shadows}
+  Spacing:  ${selected.spacing}
+  `));
+}
+async function generatePalette() {
+  const brandColor = await p12.text({
+    message: "Enter your brand color (hex):",
+    placeholder: "#6366F1",
+    validate: (v) => {
+      if (!v.match(/^#[0-9A-Fa-f]{6}$/)) return "Enter a valid hex color (#RRGGBB)";
+      return void 0;
+    }
+  });
+  if (p12.isCancel(brandColor)) return;
+  const palette = generateColorPalette(brandColor);
+  const configPath = path10.join(process.cwd(), ".codebakers", "design.json");
+  let config = {};
+  if (await fs10.pathExists(configPath)) {
+    config = await fs10.readJson(configPath);
+  }
+  await fs10.writeJson(configPath, {
+    ...config,
+    colors: palette,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, { spaces: 2 });
+  p12.log.success("Color palette generated!");
+  console.log(`
+  ${chalk13.bgHex(palette.brand[500]).black("  Brand  ")} ${palette.brand[500]}
+  ${chalk13.bgHex(palette.brand[100]).black("  Light  ")} ${palette.brand[100]}
+  ${chalk13.bgHex(palette.brand[900]).white("  Dark   ")} ${palette.brand[900]}
+  ${chalk13.bgHex(palette.accent).black(" Accent  ")} ${palette.accent}
+  `);
+}
+function generateColorPalette(hex) {
+  const r = parseInt(hex.slice(1, 3), 16) / 255;
+  const g = parseInt(hex.slice(3, 5), 16) / 255;
+  const b = parseInt(hex.slice(5, 7), 16) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h = 0, s = 0, l = (max + min) / 2;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+        break;
+      case g:
+        h = ((b - r) / d + 2) / 6;
+        break;
+      case b:
+        h = ((r - g) / d + 4) / 6;
+        break;
+    }
+  }
+  h = Math.round(h * 360);
+  s = Math.round(s * 100);
+  l = Math.round(l * 100);
+  const hslToHex = (h2, s2, l2) => {
+    l2 /= 100;
+    const a = s2 * Math.min(l2, 1 - l2) / 100;
+    const f = (n) => {
+      const k = (n + h2 / 30) % 12;
+      const color = l2 - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+      return Math.round(255 * color).toString(16).padStart(2, "0");
+    };
+    return `#${f(0)}${f(8)}${f(4)}`;
+  };
+  return {
+    brand: {
+      50: hslToHex(h, s * 0.3, 97),
+      100: hslToHex(h, s * 0.4, 94),
+      200: hslToHex(h, s * 0.5, 86),
+      300: hslToHex(h, s * 0.6, 74),
+      400: hslToHex(h, s * 0.8, 62),
+      500: hex,
+      // Original
+      600: hslToHex(h, s, l * 0.85),
+      700: hslToHex(h, s, l * 0.7),
+      800: hslToHex(h, s, l * 0.55),
+      900: hslToHex(h, s, l * 0.4)
+    },
+    accent: hslToHex((h + 180) % 360, s, l)
+    // Complementary
+  };
+}
+async function checkDesign() {
+  const spinner11 = p12.spinner();
+  spinner11.start("Checking design quality...");
+  const cwd = process.cwd();
+  const issues = [];
+  const glob3 = (await import("fast-glob")).default;
+  const files = await glob3(["src/**/*.{tsx,jsx}"], { cwd });
+  for (const file of files) {
+    const content = await fs10.readFile(path10.join(cwd, file), "utf-8");
+    if (content.includes("bg-gradient-to-r from-blue-500") || content.includes("bg-gradient-to-r from-purple-500")) {
+      issues.push(`${file}: Generic gradient hero detected`);
+    }
+    const iconMatches = content.match(/<(Rocket|Shield|Zap|Star|Check|Lightning)/g);
+    if (iconMatches && iconMatches.length > 3) {
+      issues.push(`${file}: Too many generic icons (${iconMatches.length})`);
+    }
+    if (content.includes(">Get Started<") || content.includes(">Learn More<")) {
+      issues.push(`${file}: Generic CTA text - be more specific`);
+    }
+    if (content.includes("No data") || content.includes("Nothing here")) {
+      issues.push(`${file}: Lazy empty state - add helpful message`);
+    }
+    if (content.includes("py-4") || content.includes("py-6") || content.includes("py-8")) {
+      if (content.includes("<section")) {
+        issues.push(`${file}: Section padding too small - use py-16 or larger`);
+      }
+    }
+  }
+  spinner11.stop("Check complete");
+  if (issues.length === 0) {
+    console.log(chalk13.green("\n\u2713 No design issues found!\n"));
+  } else {
+    console.log(chalk13.yellow(`
+\u26A0\uFE0F  ${issues.length} design issues found:
+`));
+    for (const issue of issues) {
+      console.log(chalk13.dim(`  \u2022 ${issue}`));
+    }
+    console.log("");
+  }
+}
+async function viewSettings() {
+  const configPath = path10.join(process.cwd(), ".codebakers", "design.json");
+  if (!await fs10.pathExists(configPath)) {
+    p12.log.info("No design settings configured. Run `codebakers design profile` to set up.");
+    return;
+  }
+  const config = await fs10.readJson(configPath);
+  console.log(chalk13.bold("\nCurrent Design Settings:\n"));
+  console.log(`  Profile:  ${config.name || config.profile}`);
+  console.log(`  Fonts:    ${config.fonts?.heading} / ${config.fonts?.body}`);
+  console.log(`  Corners:  ${config.corners}`);
+  console.log(`  Shadows:  ${config.shadows}`);
+  console.log(`  Spacing:  ${config.spacing}`);
+  if (config.colors) {
+    console.log(`  Brand:    ${config.colors.brand?.[500]}`);
+    console.log(`  Accent:   ${config.colors.accent}`);
+  }
+  console.log("");
+}
+
+// src/index.ts
+var VERSION2 = "1.0.0";
+var logo = `
+   \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
+  \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551
+  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551
+   \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`;
+async function showMainMenu() {
+  const config = new Config();
+  const isSetup = config.isConfigured();
+  console.log(gradient.pastel.multiline(logo));
+  console.log(chalk14.dim(`  v${VERSION2} \u2014 AI dev team that follows the rules
+`));
+  if (!isSetup) {
+    console.log(boxen(
+      chalk14.yellow("Welcome to CodeBakers! Let's get you set up."),
+      { padding: 1, borderColor: "yellow", borderStyle: "round" }
+    ));
+    await setupCommand();
+    return;
+  }
+  const inProject = config.isInProject();
+  const action = await p13.select({
+    message: "What do you want to do?",
+    options: inProject ? [
+      { value: "code", label: "\u{1F4AC} Code with AI", hint: "build features, fix bugs" },
+      { value: "check", label: "\u{1F50D} Check code quality", hint: "run pattern enforcement" },
+      { value: "deploy", label: "\u{1F680} Deploy", hint: "deploy to Vercel" },
+      { value: "fix", label: "\u{1F527} Fix errors", hint: "auto-fix build/deploy errors" },
+      { value: "generate", label: "\u26A1 Generate", hint: "scaffold components, pages" },
+      { value: "status", label: "\u{1F4CA} Project status", hint: "view project health" },
+      { value: "separator1", label: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" },
+      { value: "connect", label: "\u{1F517} Connect service", hint: "add integrations" },
+      { value: "gateway", label: "\u{1F4F1} Channel gateway", hint: "WhatsApp, Telegram, etc." },
+      { value: "learn", label: "\u{1F9E0} Learning settings", hint: "view what I've learned" },
+      { value: "security", label: "\u{1F512} Security audit", hint: "check for vulnerabilities" },
+      { value: "design", label: "\u{1F3A8} Design system", hint: "set profile, colors" },
+      { value: "separator2", label: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" },
+      { value: "new", label: "\u{1F195} Create new project" },
+      { value: "settings", label: "\u2699\uFE0F  Settings" },
+      { value: "help", label: "\u2753 Help" }
+    ] : [
+      { value: "new", label: "\u{1F195} Create new project" },
+      { value: "open", label: "\u{1F4C2} Open existing project" },
+      { value: "status", label: "\u{1F4CA} View all projects" },
+      { value: "separator1", label: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" },
+      { value: "connect", label: "\u{1F517} Connect service" },
+      { value: "gateway", label: "\u{1F4F1} Channel gateway", hint: "WhatsApp, Telegram, etc." },
+      { value: "learn", label: "\u{1F9E0} Learning settings" },
+      { value: "settings", label: "\u2699\uFE0F  Settings" },
+      { value: "help", label: "\u2753 Help" }
+    ]
+  });
+  if (p13.isCancel(action)) {
+    p13.cancel("Goodbye!");
+    process.exit(0);
+  }
+  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":
+      showHelp2();
+      break;
+    default:
+      await showMainMenu();
+  }
+}
+function showHelp2() {
+  console.log(boxen(`
+${chalk14.bold("CodeBakers CLI")} \u2014 AI dev team that follows the rules
+
+${chalk14.bold("Commands:")}
+  ${chalk14.cyan("codebakers")}              Interactive menu (or just run with no args)
+  ${chalk14.cyan("codebakers init")}         Create a new project
+  ${chalk14.cyan("codebakers code")}         Start AI coding session
+  ${chalk14.cyan("codebakers check")}        Run pattern enforcement
+  ${chalk14.cyan("codebakers deploy")}       Deploy to production
+  ${chalk14.cyan("codebakers fix")}          Auto-fix errors
+  ${chalk14.cyan("codebakers generate")}     Generate components/pages
+  ${chalk14.cyan("codebakers connect")}      Connect external services
+  ${chalk14.cyan("codebakers gateway")}      Manage messaging channels
+  ${chalk14.cyan("codebakers status")}       View project status
+  ${chalk14.cyan("codebakers security")}     Run security audit
+  ${chalk14.cyan("codebakers learn")}        View/manage learning
+
+${chalk14.bold("Help at any time:")}
+  Press ${chalk14.yellow("?")} during any command to get contextual help
+
+${chalk14.bold("Documentation:")}
+  ${chalk14.dim("https://codebakers.dev/docs")}
+`, { padding: 1, borderColor: "cyan", borderStyle: "round" }));
+}
+var program = new Command();
+program.name("codebakers").description("AI dev team that follows the rules").version(VERSION2).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);
+var args = process.argv.slice(2);
+if (args.length === 0) {
+  checkForUpdates().catch(() => {
+  });
+  showMainMenu().catch(console.error);
+} else {
+  program.parse();
+}