@codebakers/cli 1.1.1 → 1.1.2

package/dist/index.js

@@ -8,7 +8,7 @@ import {
 
 // src/index.ts
 import { Command } from "commander";
-import chalk2 from "chalk";
+import chalk4 from "chalk";
 
 // src/commands/setup.ts
 import inquirer from "inquirer";
@@ -93,6 +93,19 @@ async function fetchPatterns(patterns) {
 }
 
 // src/commands/setup.ts
+var CODEBAKERS_MARKER = "# CODEBAKERS SMART ROUTER";
+var USER_CONTENT_SEPARATOR = `
+
+---
+
+# USER CUSTOM INSTRUCTIONS
+
+The following instructions were preserved from your original CLAUDE.md file.
+CodeBakers patterns will be applied first, then these instructions.
+
+---
+
+`;
 var IDE_CONFIGS = {
   cursor: {
     file: ".cursor/mcp.json",
@@ -180,6 +193,7 @@ Validation failed: ${validation.error || "Unknown error"}`));
     if (ide) {
       await configureIDE(ide, options.force);
     }
+    await installClaudeMd(apiKey, options.force);
     const firstName = userName?.split(" ")[0];
     const greeting = firstName ? `${firstName}, you're` : "You're";
     console.log(chalk.bold.green("\n\u{1F389} Setup complete!\n"));
@@ -276,6 +290,78 @@ async function configureMCP(ide, force, spinner) {
     console.log(chalk.yellow("Restart your IDE to activate the MCP server.\n"));
   }
 }
+async function fetchClaudeMdFromApi(apiKey) {
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/api/cli/claude-md`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.content || null;
+  } catch {
+    return null;
+  }
+}
+async function installClaudeMd(apiKey, force) {
+  const spinner = ora("Setting up CLAUDE.md...").start();
+  const claudeMdPath = join(process.cwd(), "CLAUDE.md");
+  try {
+    spinner.text = "Fetching CLAUDE.md from CodeBakers...";
+    const codebakersContent = await fetchClaudeMdFromApi(apiKey);
+    if (!codebakersContent) {
+      spinner.warn("Could not fetch CLAUDE.md from API. Skipping...");
+      console.log(chalk.dim("  You can manually add CLAUDE.md later.\n"));
+      return;
+    }
+    if (existsSync(claudeMdPath)) {
+      const existingContent = await readFile(claudeMdPath, "utf-8");
+      const isCodeBakersFile = existingContent.trim().startsWith(CODEBAKERS_MARKER);
+      if (isCodeBakersFile) {
+        await writeFile(claudeMdPath, codebakersContent, "utf-8");
+        spinner.succeed("Updated CLAUDE.md to latest version");
+      } else {
+        if (!force) {
+          spinner.stop();
+          console.log(chalk.cyan("\n  \u2139\uFE0F  Your custom instructions will be preserved at the end of the file."));
+          console.log(chalk.dim("     CodeBakers patterns load first, then your rules apply on top."));
+          console.log(chalk.dim("     Your original content remains intact and can still override patterns.\n"));
+          const { shouldMerge } = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "shouldMerge",
+              message: "Merge with CodeBakers?",
+              default: true
+            }
+          ]);
+          if (!shouldMerge) {
+            console.log(chalk.yellow("  Skipping CLAUDE.md installation.\n"));
+            return;
+          }
+          spinner.start("Merging CLAUDE.md...");
+        }
+        const mergedContent = codebakersContent + USER_CONTENT_SEPARATOR + existingContent;
+        await writeFile(claudeMdPath, mergedContent, "utf-8");
+        spinner.succeed("Merged CLAUDE.md (your custom instructions preserved at the end)");
+      }
+    } else {
+      await writeFile(claudeMdPath, codebakersContent, "utf-8");
+      spinner.succeed("Created CLAUDE.md");
+    }
+    console.log(chalk.green("\u2713 CLAUDE.md installed"));
+    console.log(chalk.dim("  This file tells your AI to use CodeBakers patterns.\n"));
+  } catch (error) {
+    spinner.fail("Failed to install CLAUDE.md");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.log(chalk.dim(`  Error: ${message}
+`));
+  }
+}
 
 // src/commands/serve.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -476,34 +562,426 @@ ${text}`).join("\n\n---\n\n");
   });
 }
 
+// src/commands/validate.ts
+import chalk2 from "chalk";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
+function validateStateFile(projectRoot) {
+  const result = { valid: true, errors: [], warnings: [] };
+  const statePath = join2(projectRoot, ".codebakers.json");
+  if (!existsSync2(statePath)) {
+    result.warnings.push("No .codebakers.json found");
+    return result;
+  }
+  try {
+    const content = readFileSync(statePath, "utf-8");
+    JSON.parse(content);
+  } catch (error) {
+    result.valid = false;
+    result.errors.push(`Invalid JSON in .codebakers.json: ${error}`);
+  }
+  return result;
+}
+function validateContextSummaries(projectRoot) {
+  const result = { valid: true, errors: [], warnings: [] };
+  const statePath = join2(projectRoot, ".codebakers.json");
+  if (!existsSync2(statePath)) return result;
+  const state = JSON.parse(readFileSync(statePath, "utf-8"));
+  if (!state.build?.fileToTaskMap) return result;
+  const trackedFiles = Object.keys(state.build.fileToTaskMap);
+  const contextFiles = state.context ? Object.keys(state.context) : [];
+  const missingContext = [];
+  for (const file of trackedFiles) {
+    if (file.endsWith(".json") || file.endsWith(".config.ts") || file.endsWith(".config.js")) {
+      continue;
+    }
+    if (file.startsWith("src/") && !contextFiles.includes(file)) {
+      missingContext.push(file);
+    }
+  }
+  if (missingContext.length > 0) {
+    result.warnings.push(`Missing context summaries: ${missingContext.length} files`);
+  }
+  return result;
+}
+function validateContracts(projectRoot) {
+  const result = { valid: true, errors: [], warnings: [] };
+  const statePath = join2(projectRoot, ".codebakers.json");
+  if (!existsSync2(statePath)) return result;
+  const state = JSON.parse(readFileSync(statePath, "utf-8"));
+  if (!state.contracts) return result;
+  for (const [featureName, contract] of Object.entries(state.contracts)) {
+    if (!contract.expects) continue;
+    for (const depName of Object.keys(contract.expects)) {
+      if (depName === "environment" || depName === "database") continue;
+      if (typeof contract.expects[depName] === "object" && !state.contracts[depName]) {
+        result.warnings.push(`'${featureName}' expects '${depName}' but no contract found`);
+      }
+    }
+  }
+  return result;
+}
+function validateBuildState(projectRoot) {
+  const result = { valid: true, errors: [], warnings: [] };
+  const statePath = join2(projectRoot, ".codebakers.json");
+  if (!existsSync2(statePath)) return result;
+  const state = JSON.parse(readFileSync(statePath, "utf-8"));
+  if (!state.build) return result;
+  let inProgressCount = 0;
+  for (const phase of state.build.phases || []) {
+    for (const task of phase.tasks || []) {
+      if (task.status === "in_progress") {
+        inProgressCount++;
+      }
+    }
+  }
+  if (inProgressCount > 1) {
+    result.warnings.push(`${inProgressCount} tasks marked in_progress (should be 1)`);
+  }
+  return result;
+}
+function validateFileExistence(projectRoot) {
+  const result = { valid: true, errors: [], warnings: [] };
+  const statePath = join2(projectRoot, ".codebakers.json");
+  if (!existsSync2(statePath)) return result;
+  const state = JSON.parse(readFileSync(statePath, "utf-8"));
+  if (!state.build?.fileToTaskMap) return result;
+  const missingFiles = [];
+  for (const file of Object.keys(state.build.fileToTaskMap)) {
+    const filePath = join2(projectRoot, file);
+    if (!existsSync2(filePath)) {
+      missingFiles.push(file);
+    }
+  }
+  if (missingFiles.length > 0) {
+    result.errors.push(`${missingFiles.length} tracked files don't exist`);
+    result.valid = false;
+  }
+  return result;
+}
+function showBuildStatus(projectRoot) {
+  const statePath = join2(projectRoot, ".codebakers.json");
+  if (!existsSync2(statePath)) {
+    console.log(chalk2.dim("\nNo active build found."));
+    return;
+  }
+  const state = JSON.parse(readFileSync(statePath, "utf-8"));
+  if (!state.build) {
+    console.log(chalk2.dim("\nNo active build found."));
+    return;
+  }
+  console.log(chalk2.bold(`
+\u{1F4CA} Build: ${state.build.projectName || "Unnamed Project"}`));
+  console.log("");
+  for (const phase of state.build.phases || []) {
+    const tasks = phase.tasks || [];
+    const completed = tasks.filter((t) => t.status === "completed").length;
+    const total = tasks.length;
+    const pct = total > 0 ? Math.round(completed / total * 100) : 0;
+    const bar = "\u2588".repeat(Math.round(pct / 10)) + "\u2591".repeat(10 - Math.round(pct / 10));
+    let status = "";
+    if (phase.status === "complete") {
+      status = chalk2.green("\u2705");
+    } else if (phase.status === "in_progress") {
+      status = chalk2.yellow("\u{1F504}");
+    } else {
+      status = chalk2.dim("\u23F3");
+    }
+    console.log(`${status} Phase ${phase.id}: ${phase.name} [${bar}] ${pct}%`);
+  }
+  if (state.build.stats) {
+    console.log("");
+    console.log(chalk2.dim(`Tasks: ${state.build.stats.completedTasks}/${state.build.stats.totalTasks} completed`));
+  }
+  if (state.build.currentTaskId) {
+    for (const phase of state.build.phases || []) {
+      const task = phase.tasks?.find((t) => t.id === state.build.currentTaskId);
+      if (task) {
+        console.log("");
+        console.log(chalk2.bold("Current Task:"));
+        console.log(`  ${task.id}: ${task.title}`);
+        break;
+      }
+    }
+  }
+  if (state.context) {
+    const contextCount = Object.keys(state.context).length;
+    console.log("");
+    console.log(chalk2.dim(`Context summaries: ${contextCount} files`));
+  }
+  if (state.contracts) {
+    const contractCount = Object.keys(state.contracts).length;
+    console.log(chalk2.dim(`Feature contracts: ${contractCount} defined`));
+  }
+}
+function validateCommand(program2) {
+  const cmd = program2.command("validate").description("Validate architectural coherence of the project").option("-v, --verbose", "Show detailed output").option("--status", "Show build status summary").action(async (options) => {
+    const projectRoot = process.cwd();
+    console.log(chalk2.bold("\n\u{1F50D} CodeBakers Coherence Validator\n"));
+    if (options.status) {
+      showBuildStatus(projectRoot);
+      console.log("");
+      return;
+    }
+    const validators = [
+      { name: "State File", fn: validateStateFile },
+      { name: "Context Summaries", fn: validateContextSummaries },
+      { name: "Contracts", fn: validateContracts },
+      { name: "Build State", fn: validateBuildState },
+      { name: "File Existence", fn: validateFileExistence }
+    ];
+    let hasErrors = false;
+    let hasWarnings = false;
+    for (const { name, fn } of validators) {
+      const result = fn(projectRoot);
+      if (result.errors.length > 0) {
+        hasErrors = true;
+        console.log(chalk2.red(`\u274C ${name}:`));
+        for (const error of result.errors) {
+          console.log(chalk2.red(`   ${error}`));
+        }
+      } else if (result.warnings.length > 0) {
+        hasWarnings = true;
+        console.log(chalk2.yellow(`\u26A0\uFE0F  ${name}:`));
+        for (const warning of result.warnings) {
+          console.log(chalk2.yellow(`   ${warning}`));
+        }
+      } else {
+        console.log(chalk2.green(`\u2705 ${name}`));
+      }
+    }
+    console.log("");
+    if (hasErrors) {
+      console.log(chalk2.red("Validation FAILED"));
+      process.exit(1);
+    } else if (hasWarnings) {
+      console.log(chalk2.yellow("Validation passed with warnings"));
+    } else {
+      console.log(chalk2.green("All validations passed"));
+    }
+    showBuildStatus(projectRoot);
+    console.log("");
+  });
+}
+
+// src/commands/summarize.ts
+import chalk3 from "chalk";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join3, relative, extname } from "path";
+function detectFileType(filePath) {
+  const ext = extname(filePath);
+  const name = filePath.toLowerCase();
+  if (name.includes("schema") || name.includes("/db/")) return "schema";
+  if (name.includes("/api/") || name.includes("route.ts")) return "api";
+  if (name.includes("middleware")) return "middleware";
+  if (name.includes("/components/")) return "component";
+  if (name.includes("/hooks/") || name.startsWith("use")) return "hook";
+  if (name.includes("/lib/") || name.includes("/utils/")) return "utility";
+  if (name.includes(".test.") || name.includes(".spec.")) return "test";
+  return "unknown";
+}
+function generateSummaryTemplate(filePath, content) {
+  const fileType = detectFileType(filePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const exportMatches = content.match(/export\s+(const|function|class|type|interface|enum)\s+(\w+)/g) || [];
+  const exports = exportMatches.map((m) => {
+    const match = m.match(/export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/);
+    return match ? match[1] : "";
+  }).filter(Boolean);
+  const base = {
+    purpose: `[TODO: Describe what this ${fileType} does]`,
+    exports: exports.length > 0 ? exports : void 0,
+    createdAt: now
+  };
+  switch (fileType) {
+    case "schema":
+      return {
+        ...base,
+        purpose: "[TODO: Describe this database schema]",
+        schema: {},
+        relations: []
+      };
+    case "api":
+      return {
+        ...base,
+        purpose: "[TODO: Describe this API endpoint]",
+        method: content.includes("POST") ? "POST" : content.includes("PUT") ? "PUT" : content.includes("DELETE") ? "DELETE" : "GET",
+        input: {},
+        output: {},
+        sideEffects: []
+      };
+    case "middleware":
+      return {
+        ...base,
+        purpose: "[TODO: Describe this middleware]",
+        behavior: {},
+        protectedRoutes: [],
+        publicRoutes: []
+      };
+    case "component":
+      return {
+        ...base,
+        purpose: "[TODO: Describe this component]",
+        props: [],
+        state: [],
+        events: []
+      };
+    case "hook":
+      return {
+        ...base,
+        purpose: "[TODO: Describe this hook]",
+        params: [],
+        returns: "[TODO]",
+        sideEffects: []
+      };
+    case "utility":
+      return {
+        ...base,
+        purpose: "[TODO: Describe this utility]",
+        dependencies: [],
+        patterns: {}
+      };
+    default:
+      return base;
+  }
+}
+function ensureStateFile(projectRoot) {
+  const statePath = join3(projectRoot, ".codebakers.json");
+  if (existsSync3(statePath)) {
+    return JSON.parse(readFileSync2(statePath, "utf-8"));
+  }
+  const initial = {
+    version: "2.0",
+    context: {}
+  };
+  writeFileSync(statePath, JSON.stringify(initial, null, 2));
+  return initial;
+}
+function summarizeCommand(program2) {
+  program2.command("summarize [file]").description("Generate or update context summary for a file").option("-a, --all", "Generate summaries for all tracked files").option("--show", "Show existing summary without modifying").action(async (file, options) => {
+    const projectRoot = process.cwd();
+    const statePath = join3(projectRoot, ".codebakers.json");
+    console.log(chalk3.bold("\n\u{1F4DD} CodeBakers Context Summarizer\n"));
+    const state = ensureStateFile(projectRoot);
+    if (!state.context) {
+      state.context = {};
+    }
+    if (options.all) {
+      if (!state.build?.fileToTaskMap) {
+        console.log(chalk3.yellow("No tracked files found in build."));
+        console.log(chalk3.dim("Run /build command first to start tracking files."));
+        return;
+      }
+      const files = Object.keys(state.build.fileToTaskMap);
+      let generated = 0;
+      let skipped = 0;
+      for (const f of files) {
+        if (f.endsWith(".json") || f.endsWith(".config.ts")) {
+          skipped++;
+          continue;
+        }
+        const filePath = join3(projectRoot, f);
+        if (!existsSync3(filePath)) {
+          console.log(chalk3.yellow(`\u26A0\uFE0F  ${f} - file not found`));
+          continue;
+        }
+        if (state.context[f]) {
+          console.log(chalk3.dim(`   ${f} - already has summary`));
+          skipped++;
+          continue;
+        }
+        const content = readFileSync2(filePath, "utf-8");
+        const summary = generateSummaryTemplate(f, content);
+        state.context[f] = summary;
+        generated++;
+        console.log(chalk3.green(`\u2705 ${f}`));
+      }
+      writeFileSync(statePath, JSON.stringify(state, null, 2));
+      console.log("");
+      console.log(chalk3.bold(`Generated: ${generated} | Skipped: ${skipped}`));
+      console.log(chalk3.dim("\nEdit .codebakers.json to fill in [TODO] placeholders."));
+    } else if (file) {
+      const relativePath = relative(projectRoot, join3(projectRoot, file));
+      const filePath = join3(projectRoot, file);
+      if (!existsSync3(filePath)) {
+        console.log(chalk3.red(`File not found: ${file}`));
+        process.exit(1);
+      }
+      if (options.show && state.context[relativePath]) {
+        console.log(chalk3.bold(`Summary for ${relativePath}:
+`));
+        console.log(JSON.stringify(state.context[relativePath], null, 2));
+        return;
+      }
+      const content = readFileSync2(filePath, "utf-8");
+      const summary = generateSummaryTemplate(relativePath, content);
+      if (state.context[relativePath]) {
+        console.log(chalk3.yellow(`Updating existing summary for ${relativePath}`));
+        state.context[relativePath] = {
+          ...summary,
+          ...state.context[relativePath],
+          exports: summary.exports
+          // Always update exports
+        };
+      } else {
+        state.context[relativePath] = summary;
+        console.log(chalk3.green(`Created summary for ${relativePath}`));
+      }
+      writeFileSync(statePath, JSON.stringify(state, null, 2));
+      console.log("");
+      console.log(chalk3.bold("Summary:"));
+      console.log(JSON.stringify(state.context[relativePath], null, 2));
+      console.log("");
+      console.log(chalk3.dim("Edit .codebakers.json to fill in [TODO] placeholders."));
+    } else {
+      console.log("Usage:");
+      console.log("  codebakers summarize <file>     Generate summary for a specific file");
+      console.log("  codebakers summarize --all      Generate summaries for all tracked files");
+      console.log("  codebakers summarize <file> --show  Show existing summary");
+      console.log("");
+      const contextCount = Object.keys(state.context).length;
+      const todoCount = Object.values(state.context).filter(
+        (c) => JSON.stringify(c).includes("[TODO]")
+      ).length;
+      console.log(chalk3.bold("Current Status:"));
+      console.log(`  Summaries: ${contextCount}`);
+      if (todoCount > 0) {
+        console.log(chalk3.yellow(`  Need attention: ${todoCount} with [TODO] placeholders`));
+      }
+    }
+  });
+}
+
 // 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);
+validateCommand(program);
+summarizeCommand(program);
 program.command("status").description("Check CodeBakers configuration status").action(() => {
-  console.log(chalk2.bold("\n\u{1F36A} CodeBakers Status\n"));
+  console.log(chalk4.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}`));
+    console.log(chalk4.green("\u2713 API key configured"));
+    console.log(chalk4.dim(`  Key: ${maskedKey}`));
   } else {
-    console.log(chalk2.red("\u2717 No API key configured"));
-    console.log(chalk2.dim("  Run: codebakers setup"));
+    console.log(chalk4.red("\u2717 No API key configured"));
+    console.log(chalk4.dim("  Run: codebakers setup"));
   }
   const apiUrl = getApiUrl();
-  console.log(chalk2.dim(`
+  console.log(chalk4.dim(`
 API URL: ${apiUrl}`));
   if (apiUrl !== "https://codebakers.ai") {
-    console.log(chalk2.yellow("\u26A0 Warning: API URL is not the default. Run `codebakers logout` to reset."));
+    console.log(chalk4.yellow("\u26A0 Warning: API URL is not the default. Run `codebakers logout` to reset."));
   }
-  console.log(chalk2.dim(`Config path: ${getConfigPath()}
+  console.log(chalk4.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"));
+  console.log(chalk4.green("\n\u2713 API key removed\n"));
 });
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebakers/cli",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "CodeBakers CLI - AI prompt patterns for production-ready code",
   "main": "dist/index.js",
   "bin": {
@@ -11,7 +11,11 @@
     "build": "tsup src/index.ts --format esm --dts --clean",
     "dev": "tsup src/index.ts --format esm --watch",
     "prepublishOnly": "npm run build",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration"
   },
   "files": [
     "dist"
@@ -46,6 +50,7 @@
   "devDependencies": {
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.11.0",
+    "@vitest/coverage-v8": "^1.2.0",
     "tsup": "^8.0.2",
     "typescript": "^5.3.3",
     "vitest": "^1.2.0"