codebakers 2.0.3 → 2.0.10

package/dist/chunk-RCC7FYEU.js

@@ -0,0 +1,319 @@
+// 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");
+    if (fs.existsSync(codebakersDir) || fs.existsSync(claudeFile)) {
+      return true;
+    }
+    const projectIndicators = [
+      "package.json",
+      "next.config.js",
+      "next.config.mjs",
+      "next.config.ts",
+      "vite.config.ts",
+      "vite.config.js",
+      "remix.config.js",
+      "astro.config.mjs"
+    ];
+    const hasProjectFile = projectIndicators.some(
+      (file) => fs.existsSync(path.join(cwd, file))
+    );
+    if (hasProjectFile) {
+      this.autoInitExisting(cwd);
+      return true;
+    }
+    return false;
+  }
+  // Auto-initialize CodeBakers in an existing project
+  autoInitExisting(cwd) {
+    try {
+      let framework = "unknown";
+      let ui = "unknown";
+      if (fs.existsSync(path.join(cwd, "next.config.js")) || fs.existsSync(path.join(cwd, "next.config.mjs")) || fs.existsSync(path.join(cwd, "next.config.ts"))) {
+        framework = "nextjs";
+      } else if (fs.existsSync(path.join(cwd, "vite.config.ts")) || fs.existsSync(path.join(cwd, "vite.config.js"))) {
+        framework = "vite";
+      } else if (fs.existsSync(path.join(cwd, "remix.config.js"))) {
+        framework = "remix";
+      } else if (fs.existsSync(path.join(cwd, "astro.config.mjs"))) {
+        framework = "astro";
+      }
+      const pkgPath = path.join(cwd, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const pkg = fs.readJsonSync(pkgPath);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps["@shadcn/ui"] || deps["class-variance-authority"]) {
+          ui = "shadcn";
+        } else if (deps["@chakra-ui/react"]) {
+          ui = "chakra";
+        } else if (deps["@mantine/core"]) {
+          ui = "mantine";
+        } else if (deps["@mui/material"]) {
+          ui = "mui";
+        }
+      }
+      const configDir = path.join(cwd, ".codebakers");
+      fs.ensureDirSync(configDir);
+      const config = {
+        name: path.basename(cwd),
+        framework,
+        ui,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        autoDetected: true
+      };
+      fs.writeJsonSync(path.join(configDir, "config.json"), config, { spaces: 2 });
+      const gitignorePath = path.join(cwd, ".gitignore");
+      if (fs.existsSync(gitignorePath)) {
+        const gitignore = fs.readFileSync(gitignorePath, "utf-8");
+        if (!gitignore.includes(".codebakers")) {
+          fs.appendFileSync(gitignorePath, "\n# CodeBakers\n.codebakers/\n");
+        }
+      }
+    } catch {
+    }
+  }
+  // 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);
+    }
+  }
+};
+
+export {
+  Config
+};

package/dist/chunk-YGVDLNXY.js

@@ -0,0 +1,326 @@
+import {
+  Config
+} from "./chunk-RCC7FYEU.js";
+
+// src/commands/prd.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import * as fs from "fs-extra";
+import * as path from "path";
+import Anthropic from "@anthropic-ai/sdk";
+async function prdCommand(filePath) {
+  const config = new Config();
+  if (!config.isConfigured()) {
+    p.log.error("Please run `codebakers setup` first.");
+    return;
+  }
+  p.intro(chalk.bgCyan.black(" Build from PRD "));
+  let prdPath = filePath;
+  if (!prdPath) {
+    const file = await p.text({
+      message: "Path to PRD file:",
+      placeholder: "./PRD.md or paste URL",
+      validate: (v) => !v ? "File path required" : void 0
+    });
+    if (p.isCancel(file)) return;
+    prdPath = file;
+  }
+  const spinner2 = p.spinner();
+  spinner2.start("Reading PRD...");
+  let prdContent;
+  try {
+    if (prdPath.startsWith("http")) {
+      const response = await fetch(prdPath);
+      prdContent = await response.text();
+    } else {
+      prdContent = await fs.readFile(prdPath, "utf-8");
+    }
+  } catch (error) {
+    spinner2.stop("Error");
+    p.log.error(`Could not read PRD: ${error instanceof Error ? error.message : "Unknown error"}`);
+    return;
+  }
+  spinner2.stop("PRD loaded");
+  spinner2.start("Analyzing PRD...");
+  const anthropicCreds = config.getCredentials("anthropic");
+  if (!anthropicCreds?.apiKey) {
+    spinner2.stop("Error");
+    p.log.error("Anthropic API key not configured.");
+    return;
+  }
+  const anthropic = new Anthropic({ apiKey: anthropicCreds.apiKey });
+  const parsed = await parsePRD(anthropic, prdContent);
+  spinner2.stop("PRD analyzed");
+  console.log(chalk.bold("\n\u{1F4CB} Extracted from PRD:\n"));
+  console.log(`  ${chalk.cyan("Name:")} ${parsed.name}`);
+  console.log(`  ${chalk.cyan("Description:")} ${parsed.description}`);
+  console.log(`  ${chalk.cyan("Features:")} ${parsed.features.length} features`);
+  console.log(`  ${chalk.cyan("Pages:")} ${parsed.pages.join(", ") || "Auto-detect"}`);
+  console.log(`  ${chalk.cyan("Database:")} ${parsed.database.length} tables`);
+  console.log(`  ${chalk.cyan("Integrations:")} ${parsed.integrations.join(", ") || "None"}`);
+  console.log("");
+  if (parsed.features.length > 0) {
+    console.log(chalk.bold("Features to build:"));
+    parsed.features.slice(0, 10).forEach((f, i) => {
+      console.log(chalk.dim(`  ${i + 1}. ${f}`));
+    });
+    if (parsed.features.length > 10) {
+      console.log(chalk.dim(`  ... and ${parsed.features.length - 10} more`));
+    }
+    console.log("");
+  }
+  const proceed = await p.confirm({
+    message: "Build this project?",
+    initialValue: true
+  });
+  if (!proceed || p.isCancel(proceed)) {
+    p.cancel("Cancelled");
+    return;
+  }
+  const options = await p.group({
+    createInfra: () => p.confirm({
+      message: "Create GitHub + Vercel + Supabase?",
+      initialValue: true
+    }),
+    designProfile: () => p.select({
+      message: "Design profile:",
+      options: [
+        { value: "minimal", label: "Minimal (Linear, Notion)" },
+        { value: "bold", label: "Bold (Stripe, Ramp)" },
+        { value: "editorial", label: "Editorial (Medium, Substack)" },
+        { value: "playful", label: "Playful (Figma, Slack)" },
+        { value: "premium", label: "Premium (Apple, Porsche)" },
+        { value: "dashboard", label: "Dashboard (Datadog, Linear)" }
+      ],
+      initialValue: parsed.design.profile || "minimal"
+    })
+  });
+  if (p.isCancel(options)) return;
+  await buildFromPRD(parsed, options, anthropic, config);
+}
+async function parsePRD(anthropic, content) {
+  const response = await anthropic.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    messages: [{
+      role: "user",
+      content: `Analyze this PRD and extract structured information. Return JSON only, no explanation.
+
+PRD:
+${content}
+
+Return this exact JSON structure:
+{
+  "name": "project name (lowercase, hyphenated)",
+  "description": "one sentence description",
+  "features": ["feature 1", "feature 2", ...],
+  "pages": ["page1", "page2", ...],
+  "database": ["table1", "table2", ...],
+  "integrations": ["stripe", "supabase", ...],
+  "design": {
+    "profile": "minimal|bold|editorial|playful|premium|dashboard or null",
+    "brandColor": "#hexcolor or null"
+  }
+}
+
+Extract ALL features mentioned. Include auth, payments, dashboards, etc.
+For pages, list actual pages/routes needed.
+For database, list tables/entities needed.
+For integrations, list third-party services mentioned.`
+    }]
+  });
+  const text2 = response.content[0].type === "text" ? response.content[0].text : "";
+  const jsonMatch = text2.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Could not parse PRD");
+  }
+  return JSON.parse(jsonMatch[0]);
+}
+async function buildFromPRD(prd, options, anthropic, config) {
+  const spinner2 = p.spinner();
+  const projectPath = path.join(process.cwd(), prd.name);
+  spinner2.start("Creating project structure...");
+  await fs.ensureDir(projectPath);
+  await fs.ensureDir(path.join(projectPath, ".codebakers"));
+  await fs.ensureDir(path.join(projectPath, "src", "app"));
+  await fs.ensureDir(path.join(projectPath, "src", "components"));
+  await fs.ensureDir(path.join(projectPath, "src", "lib"));
+  spinner2.stop("Project structure created");
+  spinner2.start("Saving PRD...");
+  await fs.writeFile(path.join(projectPath, "PRD.md"), await fs.readFile(process.cwd(), "utf-8").catch(() => JSON.stringify(prd, null, 2)));
+  await fs.writeJson(path.join(projectPath, ".codebakers", "prd.json"), prd, { spaces: 2 });
+  await fs.writeJson(path.join(projectPath, ".codebakers", "design.json"), {
+    profile: options.designProfile,
+    colors: prd.design.brandColor ? { brand: prd.design.brandColor } : void 0
+  }, { spaces: 2 });
+  spinner2.stop("PRD saved");
+  spinner2.start("Generating build plan...");
+  const buildPlan = await generateBuildPlan(anthropic, prd, options.designProfile);
+  await fs.writeJson(path.join(projectPath, ".codebakers", "build-plan.json"), buildPlan, { spaces: 2 });
+  spinner2.stop("Build plan generated");
+  console.log(chalk.bold("\n\u{1F3D7}\uFE0F  Build Plan:\n"));
+  buildPlan.phases.forEach((phase, i) => {
+    console.log(chalk.cyan(`Phase ${i + 1}: ${phase.name}`));
+    phase.tasks.forEach((task) => {
+      console.log(chalk.dim(`  \u2022 ${task}`));
+    });
+  });
+  console.log("");
+  const startBuild = await p.confirm({
+    message: "Start building?",
+    initialValue: true
+  });
+  if (!startBuild || p.isCancel(startBuild)) {
+    p.log.info(`Build plan saved to ${prd.name}/.codebakers/build-plan.json`);
+    p.log.info(`Run \`cd ${prd.name} && codebakers code\` to continue building.`);
+    return;
+  }
+  for (let i = 0; i < buildPlan.phases.length; i++) {
+    const phase = buildPlan.phases[i];
+    console.log(chalk.bold(`
+\u{1F4E6} Phase ${i + 1}: ${phase.name}
+`));
+    for (const task of phase.tasks) {
+      spinner2.start(task);
+      try {
+        await executeTask(anthropic, projectPath, task, prd, options.designProfile);
+        spinner2.stop(`\u2713 ${task}`);
+      } catch (error) {
+        spinner2.stop(`\u2717 ${task}`);
+        p.log.error(error instanceof Error ? error.message : "Task failed");
+        const continueBuilding = await p.confirm({
+          message: "Continue with next task?",
+          initialValue: true
+        });
+        if (!continueBuilding || p.isCancel(continueBuilding)) {
+          p.log.info("Build paused. Run `codebakers code` to continue.");
+          return;
+        }
+      }
+    }
+  }
+  if (options.createInfra) {
+    console.log(chalk.bold("\n\u{1F680} Setting up infrastructure...\n"));
+    spinner2.start("Creating GitHub repository...");
+    spinner2.stop("GitHub repository created");
+    spinner2.start("Creating Supabase project...");
+    spinner2.stop("Supabase project created");
+    spinner2.start("Creating Vercel project...");
+    spinner2.stop("Vercel project created");
+    spinner2.start("Deploying...");
+    spinner2.stop("Deployed!");
+  }
+  p.outro(chalk.green(`
+\u2713 Project built from PRD!
+
+${chalk.bold("Your project:")}
+  ${chalk.cyan(`cd ${prd.name}`)}
+  ${chalk.cyan("npm run dev")}
+
+${chalk.bold("Continue building:")}
+  ${chalk.cyan("codebakers code")} \u2014 AI agent
+  ${chalk.cyan("codebakers check")} \u2014 Verify patterns
+  ${chalk.cyan("codebakers deploy")} \u2014 Deploy changes
+`));
+}
+async function generateBuildPlan(anthropic, prd, designProfile) {
+  const response = await anthropic.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    messages: [{
+      role: "user",
+      content: `Create a build plan for this project. Return JSON only.
+
+Project: ${prd.name}
+Description: ${prd.description}
+Features: ${prd.features.join(", ")}
+Pages: ${prd.pages.join(", ")}
+Database tables: ${prd.database.join(", ")}
+Integrations: ${prd.integrations.join(", ")}
+Design: ${designProfile}
+
+Return this structure:
+{
+  "phases": [
+    {
+      "name": "Phase name",
+      "tasks": ["task 1", "task 2", ...]
+    }
+  ]
+}
+
+Phases should be:
+1. Setup (package.json, config, base files)
+2. Database (schema, migrations, types)
+3. Auth (if needed)
+4. Core Features (main functionality)
+5. UI/Pages (frontend)
+6. Integrations (third-party services)
+7. Polish (loading states, error handling, empty states)
+
+Keep tasks specific and actionable.`
+    }]
+  });
+  const text2 = response.content[0].type === "text" ? response.content[0].text : "";
+  const jsonMatch = text2.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Could not generate build plan");
+  }
+  return JSON.parse(jsonMatch[0]);
+}
+async function executeTask(anthropic, projectPath, task, prd, designProfile) {
+  const response = await anthropic.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 8192,
+    messages: [{
+      role: "user",
+      content: `Execute this task for the project.
+
+Project: ${prd.name}
+Task: ${task}
+Design Profile: ${designProfile}
+
+Context:
+- Features: ${prd.features.join(", ")}
+- Database: ${prd.database.join(", ")}
+
+Output files in this format:
+
+<<<FILE: path/to/file.ts>>>
+file content here
+<<<END_FILE>>>
+
+<<<FILE: another/file.tsx>>>
+file content here  
+<<<END_FILE>>>
+
+Follow these rules:
+- Use TypeScript
+- Use Next.js App Router
+- Use Tailwind CSS
+- Use shadcn/ui components
+- Every button needs onClick handler
+- Every form needs Zod validation
+- Every async operation needs loading/error states
+- Every list needs empty state
+- No generic gradient heroes
+- No icon spam
+- Generous spacing (py-16 or larger for sections)
+
+Generate ALL files needed for this task.`
+    }]
+  });
+  const text2 = response.content[0].type === "text" ? response.content[0].text : "";
+  const fileRegex = /<<<FILE:\s*(.+?)>>>([\s\S]*?)<<<END_FILE>>>/g;
+  let match;
+  while ((match = fileRegex.exec(text2)) !== null) {
+    const filePath = path.join(projectPath, match[1].trim());
+    const content = match[2].trim();
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
+  }
+}
+
+export {
+  prdCommand
+};