@codebakers/cli 1.0.0

package/README.md

@@ -0,0 +1,89 @@
+# @codebakers/cli
+
+Official CLI for CodeBakers - AI prompt patterns for production-ready code.
+
+## Installation
+
+```bash
+npx @codebakers/cli setup
+```
+
+Or install globally:
+
+```bash
+npm install -g @codebakers/cli
+codebakers setup
+```
+
+## Commands
+
+### Setup
+
+Configure CodeBakers with your API key and set up your IDE:
+
+```bash
+# Interactive setup
+npx @codebakers/cli setup
+
+# Setup for specific IDE
+npx @codebakers/cli setup --ide cursor
+npx @codebakers/cli setup --ide windsurf
+npx @codebakers/cli setup --ide aider
+npx @codebakers/cli setup --ide claude-code
+```
+
+### Claude Code MCP Server
+
+Add CodeBakers as an MCP server in Claude Code:
+
+```bash
+/mcp add codebakers npx -y @codebakers/cli serve
+```
+
+### Status
+
+Check your configuration:
+
+```bash
+npx @codebakers/cli status
+```
+
+### Logout
+
+Remove stored API key:
+
+```bash
+npx @codebakers/cli logout
+```
+
+## Supported IDEs
+
+| IDE | Configuration File |
+|-----|-------------------|
+| Cursor | `.cursorrules` |
+| Windsurf | `.windsurfrules` |
+| Aider | `.aider.conf.yml` |
+| Claude Code | `CLAUDE.md` + `.claude/` |
+
+## Getting Your API Key
+
+1. Sign up at [codebakers.ai](https://codebakers.ai)
+2. Go to Settings to find your API key
+3. Run `codebakers setup` and paste your key
+
+## What's Included
+
+CodeBakers provides 34 production-ready pattern modules:
+
+- **00-core** - Required standards, types, error handling
+- **01-database** - Drizzle ORM, queries, migrations
+- **02-auth** - Authentication, OAuth, 2FA, security
+- **03-api** - API routes, validation, rate limiting
+- **04-frontend** - React, forms, states, i18n
+- **05-payments** - Stripe, subscriptions, billing
+- **06-integrations** - Email, files, background jobs
+- And 27 more modules...
+
+## License
+
+MIT

package/dist/chunk-7CKLRE2H.js

@@ -0,0 +1,36 @@
+// src/utils/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "codebakers",
+  defaults: {
+    apiKey: null,
+    apiUrl: "https://codebakers.ai"
+  }
+});
+function getApiKey() {
+  return config.get("apiKey");
+}
+function setApiKey(key) {
+  config.set("apiKey", key);
+}
+function getApiUrl() {
+  return config.get("apiUrl");
+}
+function setApiUrl(url) {
+  config.set("apiUrl", url);
+}
+function clearConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+
+export {
+  getApiKey,
+  setApiKey,
+  getApiUrl,
+  setApiUrl,
+  clearConfig,
+  getConfigPath
+};

package/dist/config-R2H6JKGW.js

@@ -0,0 +1,16 @@
+import {
+  clearConfig,
+  getApiKey,
+  getApiUrl,
+  getConfigPath,
+  setApiKey,
+  setApiUrl
+} from "./chunk-7CKLRE2H.js";
+export {
+  clearConfig,
+  getApiKey,
+  getApiUrl,
+  getConfigPath,
+  setApiKey,
+  setApiUrl
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+import {
+  getApiKey,
+  getApiUrl,
+  getConfigPath,
+  setApiKey
+} from "./chunk-7CKLRE2H.js";
+
+// src/index.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+
+// src/commands/setup.ts
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+import { writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+
+// src/utils/api.ts
+var ApiError = class extends Error {
+  constructor(message, statusCode, code) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.name = "ApiError";
+  }
+};
+async function makeRequest(endpoint, options = {}) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new ApiError("No API key configured. Run: codebakers setup", 401);
+  }
+  const baseUrl = getApiUrl();
+  const url = `${baseUrl}${endpoint}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+      ...options.headers
+    }
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    throw new ApiError(
+      data.error || "API request failed",
+      response.status,
+      data.code
+    );
+  }
+  return data;
+}
+async function validateApiKey(apiKey) {
+  const baseUrl = getApiUrl();
+  const response = await fetch(`${baseUrl}/api/patterns`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+  return response.ok;
+}
+async function listPatterns() {
+  return makeRequest("/api/patterns");
+}
+async function fetchPatterns(patterns) {
+  return makeRequest("/api/patterns", {
+    method: "POST",
+    body: JSON.stringify({ patterns })
+  });
+}
+async function fetchAllPatterns() {
+  const list = await listPatterns();
+  const allPatterns = {};
+  const patternNames = list.patterns.map((p) => p.name);
+  for (let i = 0; i < patternNames.length; i += 5) {
+    const batch = patternNames.slice(i, i + 5);
+    const result = await fetchPatterns(batch);
+    Object.assign(allPatterns, result.patterns);
+  }
+  const routerResult = await fetchPatterns(["router"]);
+  Object.assign(allPatterns, routerResult.patterns);
+  return allPatterns;
+}
+
+// src/commands/setup.ts
+var IDE_CONFIGS = {
+  cursor: {
+    file: ".cursorrules",
+    description: "Cursor AI IDE"
+  },
+  windsurf: {
+    file: ".windsurfrules",
+    description: "Windsurf (Codeium) IDE"
+  },
+  aider: {
+    file: ".aider.conf.yml",
+    description: "Aider CLI"
+  },
+  "claude-code": {
+    file: "CLAUDE.md",
+    description: "Claude Code CLI"
+  }
+};
+function setupCommand(program2) {
+  program2.command("setup").description("Configure CodeBakers with your API key").option("--ide <type>", "IDE to configure (cursor, windsurf, aider, claude-code)").option("--key <apiKey>", "API key (or enter interactively)").option("--force", "Overwrite existing configuration").action(async (options) => {
+    console.log(chalk.bold("\n\u{1F36A} CodeBakers Setup\n"));
+    let apiKey = options.key;
+    const existingKey = getApiKey();
+    if (existingKey && !options.key) {
+      const { useExisting } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "useExisting",
+          message: "API key already configured. Use existing key?",
+          default: true
+        }
+      ]);
+      if (useExisting) {
+        apiKey = existingKey;
+      }
+    }
+    if (!apiKey) {
+      const answers = await inquirer.prompt([
+        {
+          type: "password",
+          name: "apiKey",
+          message: "Enter your CodeBakers API key:",
+          mask: "*",
+          validate: (input) => {
+            if (!input.startsWith("cb_")) {
+              return "Invalid key format. API keys start with cb_";
+            }
+            return true;
+          }
+        }
+      ]);
+      apiKey = answers.apiKey;
+    }
+    const spinner = ora("Validating API key...").start();
+    try {
+      const isValid = await validateApiKey(apiKey);
+      if (!isValid) {
+        spinner.fail("Invalid API key");
+        console.log(chalk.red("\nAPI key validation failed."));
+        console.log(chalk.dim("Get your key at: https://codebakers.ai/settings"));
+        process.exit(1);
+      }
+      spinner.succeed("API key validated");
+    } catch (error) {
+      spinner.fail("Failed to validate API key");
+      console.log(chalk.red("\nCould not connect to CodeBakers API."));
+      console.log(chalk.dim("Check your internet connection and try again."));
+      process.exit(1);
+    }
+    setApiKey(apiKey);
+    console.log(chalk.green("\n\u2713 API key saved\n"));
+    let ide = options.ide;
+    if (!ide) {
+      const { selectedIde } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "selectedIde",
+          message: "Which AI coding tool are you using?",
+          choices: [
+            { name: "Cursor", value: "cursor" },
+            { name: "Claude Code (CLI)", value: "claude-code" },
+            { name: "Windsurf (Codeium)", value: "windsurf" },
+            { name: "Aider", value: "aider" },
+            { name: "Skip for now", value: null }
+          ]
+        }
+      ]);
+      ide = selectedIde;
+    }
+    if (ide) {
+      await configureIDE(ide, options.force);
+    }
+    console.log(chalk.bold.green("\n\u{1F389} Setup complete!\n"));
+    if (ide === "claude-code") {
+      console.log(chalk.dim("Next step - add CodeBakers to Claude Code:"));
+      console.log(chalk.cyan("  /mcp add codebakers npx -y @codebakers/cli serve\n"));
+    } else if (ide) {
+      console.log(chalk.dim(`Pattern file created. Restart ${IDE_CONFIGS[ide].description} to load it.
+`));
+    }
+  });
+}
+async function configureIDE(ide, force = false) {
+  const config = IDE_CONFIGS[ide];
+  const targetPath = join(process.cwd(), config.file);
+  const spinner = ora(`Fetching CodeBakers patterns...`).start();
+  try {
+    if (ide === "claude-code") {
+      const claudeDir = join(process.cwd(), ".claude");
+      if (!existsSync(claudeDir)) {
+        await mkdir(claudeDir, { recursive: true });
+      }
+    }
+    if (existsSync(targetPath) && !force) {
+      spinner.stop();
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: `${config.file} already exists. Overwrite?`,
+          default: false
+        }
+      ]);
+      if (!overwrite) {
+        console.log(chalk.yellow("\nSetup cancelled. Use --force to overwrite."));
+        return;
+      }
+      spinner.start();
+    }
+    const patterns = await fetchAllPatterns();
+    const patternList = await listPatterns();
+    spinner.text = "Generating configuration...";
+    let content;
+    if (ide === "claude-code") {
+      content = patterns["router"] || "";
+      for (const [name, patternContent] of Object.entries(patterns)) {
+        if (name !== "router") {
+          const patternPath = join(process.cwd(), ".claude", `${name}.md`);
+          await writeFile(patternPath, patternContent, "utf-8");
+        }
+      }
+    } else if (ide === "aider") {
+      content = generateAiderConfig(patterns);
+    } else {
+      content = generateRulesFile(patterns, patternList.version);
+    }
+    await writeFile(targetPath, content, "utf-8");
+    spinner.succeed(`Created ${config.file}`);
+    if (ide === "claude-code") {
+      console.log(chalk.dim(`  + Created .claude/ folder with ${Object.keys(patterns).length - 1} pattern files`));
+    }
+    console.log(chalk.green(`
+\u2713 ${IDE_CONFIGS[ide].description} configured`));
+  } catch (error) {
+    spinner.fail("Failed to configure IDE");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.log(chalk.red(`
+Error: ${message}`));
+    process.exit(1);
+  }
+}
+function generateRulesFile(patterns, version) {
+  const router = patterns["router"] || "";
+  let content = `# CodeBakers Patterns v${version}
+# Generated by @codebakers/cli
+# https://codebakers.ai
+
+${router}
+
+---
+
+# PATTERN MODULES (Auto-loaded based on context)
+
+`;
+  for (const [name, patternContent] of Object.entries(patterns)) {
+    if (name !== "router" && patternContent) {
+      content += `
+## Module: ${name}
+
+${patternContent}
+
+---
+`;
+    }
+  }
+  return content;
+}
+function generateAiderConfig(patterns) {
+  const router = patterns["router"] || "";
+  return `# CodeBakers Aider Configuration
+# Generated by @codebakers/cli
+# https://codebakers.ai
+
+read:
+  - .codebakers-patterns.md
+
+# System message with CodeBakers patterns
+message: |
+${router.split("\n").map((line) => "  " + line).join("\n")}
+`;
+}
+
+// src/commands/serve.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function serveCommand(program2) {
+  program2.command("serve").description("Run CodeBakers as an MCP server for Claude Code").action(async () => {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      console.error("No API key configured. Run: npx @codebakers/cli setup");
+      process.exit(1);
+    }
+    const server = new Server(
+      {
+        name: "codebakers",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {}
+        }
+      }
+    );
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "get_pattern",
+            description: "Fetch a CodeBakers pattern module for production-ready code patterns. Available patterns: 00-core, 01-database, 02-auth, 03-api, 04-frontend, 05-payments, 06-integrations, 07-performance, 08-testing, 09-design, 10-generators, 11-realtime, 12-saas, 14-ai, and more.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                patterns: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: 'Pattern names to fetch (e.g., ["00-core", "02-auth"]). Max 5 per request.'
+                }
+              },
+              required: ["patterns"]
+            }
+          },
+          {
+            name: "list_patterns",
+            description: "List all available CodeBakers pattern modules",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            }
+          }
+        ]
+      };
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      try {
+        const result = await listPatterns();
+        return {
+          resources: result.patterns.map((p) => ({
+            uri: `codebakers://pattern/${p.name}`,
+            name: p.name,
+            description: `CodeBakers ${p.name} pattern module`,
+            mimeType: "text/markdown"
+          }))
+        };
+      } catch (error) {
+        return { resources: [] };
+      }
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const match = uri.match(/^codebakers:\/\/pattern\/(.+)$/);
+      if (!match) {
+        throw new Error(`Invalid resource URI: ${uri}`);
+      }
+      const patternName = match[1];
+      try {
+        const result = await fetchPatterns([patternName]);
+        const content = result.patterns[patternName];
+        if (!content) {
+          throw new Error(`Pattern not found: ${patternName}`);
+        }
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "text/markdown",
+              text: content
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof ApiError) {
+          throw new Error(`API Error: ${error.message}`);
+        }
+        throw error;
+      }
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      if (name === "list_patterns") {
+        try {
+          const result = await listPatterns();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Available CodeBakers patterns (${result.total}):
+
+${result.patterns.map((p) => `- ${p.name}`).join("\n")}
+
+Use get_pattern to fetch specific patterns.`
+              }
+            ]
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true
+          };
+        }
+      }
+      if (name === "get_pattern") {
+        const patterns = args?.patterns || [];
+        if (patterns.length === 0) {
+          return {
+            content: [
+              { type: "text", text: "Error: No patterns specified" }
+            ],
+            isError: true
+          };
+        }
+        if (patterns.length > 5) {
+          return {
+            content: [
+              { type: "text", text: "Error: Maximum 5 patterns per request" }
+            ],
+            isError: true
+          };
+        }
+        try {
+          const result = await fetchPatterns(patterns);
+          const content = Object.entries(result.patterns).map(([name2, text]) => `# Pattern: ${name2}
+
+${text}`).join("\n\n---\n\n");
+          return {
+            content: [
+              {
+                type: "text",
+                text: content || `No patterns found for: ${patterns.join(", ")}`
+              }
+            ]
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          if (error instanceof ApiError) {
+            if (error.statusCode === 401) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: "Error: Invalid API key. Run: npx @codebakers/cli setup"
+                  }
+                ],
+                isError: true
+              };
+            }
+            if (error.statusCode === 402) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Error: ${message}. Upgrade at: https://codebakers.ai/billing`
+                  }
+                ],
+                isError: true
+              };
+            }
+          }
+          return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true
+          };
+        }
+      }
+      return {
+        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+        isError: true
+      };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("codebakers").description("CodeBakers CLI - AI prompt patterns for production-ready code").version("1.0.0");
+setupCommand(program);
+serveCommand(program);
+program.command("status").description("Check CodeBakers configuration status").action(() => {
+  console.log(chalk2.bold("\n\u{1F36A} CodeBakers Status\n"));
+  const apiKey = getApiKey();
+  if (apiKey) {
+    const maskedKey = apiKey.substring(0, 10) + "..." + apiKey.slice(-4);
+    console.log(chalk2.green("\u2713 API key configured"));
+    console.log(chalk2.dim(`  Key: ${maskedKey}`));
+  } else {
+    console.log(chalk2.red("\u2717 No API key configured"));
+    console.log(chalk2.dim("  Run: codebakers setup"));
+  }
+  console.log(chalk2.dim(`
+Config path: ${getConfigPath()}
+`));
+});
+program.command("logout").description("Remove stored API key").action(async () => {
+  const { clearConfig } = await import("./config-R2H6JKGW.js");
+  clearConfig();
+  console.log(chalk2.green("\n\u2713 API key removed\n"));
+});
+program.parse();

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@codebakers/cli",
+  "version": "1.0.0",
+  "description": "CodeBakers CLI - AI prompt patterns for production-ready code",
+  "main": "dist/index.js",
+  "bin": {
+    "codebakers": "dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "codebakers",
+    "ai",
+    "prompts",
+    "cursor",
+    "claude",
+    "aider",
+    "windsurf",
+    "mcp",
+    "cli"
+  ],
+  "author": "CodeBakers",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codebakers/cli"
+  },
+  "homepage": "https://codebakers.ai",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^12.0.0",
+    "inquirer": "^9.2.23",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.11.0",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}