rebar-mcp 2.0.0

package/src/cli.ts

@@ -0,0 +1,735 @@
+#!/usr/bin/env node
+/**
+ * Rebar CLI — Standalone command-line interface
+ *
+ * Run Rebar commands without an MCP client. Useful for:
+ * - CI/CD pipelines (audit, badge generation)
+ * - Quick project setup (init, doctor)
+ * - Local development (metrics, set-strictness)
+ */
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import {
+  resolveProjectPath,
+  sanitizePath,
+  readFileSafe,
+  fileExists,
+  listFiles,
+  listFilesRecursive,
+} from "./services/file-ops.js";
+import { validateClaudeMD, validateSkillFrontmatter, validateJSON, estimateTokens } from "./services/validation.js";
+import { detectCurrentProfile, getHooksForProfile, hooksToSettingsFormat, type StrictnessProfile } from "./services/strictness.js";
+import { analyzeProject } from "./services/project-analyzer.js";
+import { generateClaudeMD as generateClaudeMDContent } from "./services/claudemd-generator.js";
+import { resolvePlatforms } from "./services/platform-detect.js";
+import { generateCursorConfig } from "./services/cursor-generator.js";
+import { generateWindsurfConfig } from "./services/windsurf-generator.js";
+import { generateCodexConfig } from "./services/codex-generator.js";
+import { atomicWrite } from "./services/file-ops.js";
+import { CONTEXT_WINDOW_TOKENS } from "./constants.js";
+
+const VERSION = "2.0.0";
+
+interface CLIOptions {
+  path: string;
+  strictness: StrictnessProfile;
+  platforms: string[];
+  format: "markdown" | "json";
+  threshold: number;
+}
+
+function parseArgs(args: string[]): { command: string; options: CLIOptions; positional: string[] } {
+  const options: CLIOptions = {
+    path: ".",
+    strictness: "standard",
+    platforms: ["all"],
+    format: "markdown",
+    threshold: 0,
+  };
+  const positional: string[] = [];
+  let command = "";
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[++i];
+
+      switch (key) {
+        case "path":
+          options.path = value;
+          break;
+        case "strictness":
+          if (value === "standard" || value === "strict" || value === "paranoid") {
+            options.strictness = value;
+          }
+          break;
+        case "platforms":
+          options.platforms = value.split(",");
+          break;
+        case "format":
+          if (value === "markdown" || value === "json") {
+            options.format = value;
+          }
+          break;
+        case "threshold":
+          options.threshold = parseInt(value, 10);
+          break;
+      }
+    } else if (arg.startsWith("-")) {
+      // Short options (ignored for now)
+    } else if (!command) {
+      command = arg;
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  return { command, options, positional };
+}
+
+async function cmdInit(options: CLIOptions): Promise<number> {
+  const projectPath = resolveProjectPath(options.path);
+  console.log(`Initializing Rebar in ${projectPath}...`);
+  console.log(`Strictness: ${options.strictness}`);
+  console.log(`Platforms: ${options.platforms.join(", ")}`);
+  console.log();
+
+  try {
+    // Analyze project
+    const analysis = await analyzeProject(projectPath);
+    console.log(`Detected tech stack: ${analysis.stacks.join(", ") || "none"}`);
+    console.log(`Project name: ${analysis.name}`);
+    console.log();
+
+    // Generate CLAUDE.md
+    const claudeMdContent = generateClaudeMDContent(analysis);
+    const claudeMdPath = path.join(projectPath, "CLAUDE.md");
+    await atomicWrite(claudeMdPath, claudeMdContent);
+    console.log("✓ Created CLAUDE.md");
+
+    // Set up directories
+    const claudeDir = path.join(projectPath, ".claude");
+    await fs.mkdir(claudeDir, { recursive: true });
+    await fs.mkdir(path.join(claudeDir, "skills"), { recursive: true });
+    await fs.mkdir(path.join(claudeDir, "agents"), { recursive: true });
+    await fs.mkdir(path.join(claudeDir, "docs"), { recursive: true });
+    console.log("✓ Created .claude/ directory structure");
+
+    // Derive commands from analysis
+    const testCmd = Object.values(analysis.testCommands)[0] || "npm test";
+    const lintCmd = analysis.linter ? `npx ${analysis.linter.toLowerCase()} .` : "npm run lint";
+    const formatCmd = analysis.formatter ? `npx ${analysis.formatter.toLowerCase()} --write .` : "npm run format";
+
+    // Generate settings with hooks based on strictness
+    const hooks = getHooksForProfile(
+      options.strictness,
+      testCmd,
+      lintCmd,
+      formatCmd
+    );
+    const settingsContent = JSON.stringify(
+      { hooks: hooksToSettingsFormat(hooks) },
+      null,
+      2
+    );
+    await atomicWrite(path.join(claudeDir, "settings.json"), settingsContent);
+    console.log(`✓ Created .claude/settings.json (${options.strictness} strictness)`);
+
+    // Generate platform-specific configs
+    const platforms = await resolvePlatforms(projectPath, options.platforms);
+    for (const platform of platforms) {
+      if (platform === "cursor") {
+        await generateCursorConfig(projectPath, analysis.name, claudeMdContent, []);
+        console.log("✓ Created .cursor/rules/ for Cursor");
+      } else if (platform === "windsurf") {
+        await generateWindsurfConfig(projectPath, claudeMdContent, []);
+        console.log("✓ Created .windsurf/rules/ for Windsurf");
+      } else if (platform === "codex") {
+        await generateCodexConfig(projectPath, analysis.name, claudeMdContent);
+        console.log("✓ Created AGENTS.md for Codex");
+      }
+    }
+
+    // Create .claudeignore
+    const claudeignorePath = path.join(projectPath, ".claudeignore");
+    if (!(await fileExists(claudeignorePath))) {
+      const claudeignoreContent = `# Rebar default .claudeignore
+node_modules/
+.git/
+dist/
+build/
+coverage/
+*.log
+.env
+.env.*
+*.pem
+*.key
+`;
+      await atomicWrite(claudeignorePath, claudeignoreContent);
+      console.log("✓ Created .claudeignore");
+    }
+
+    console.log();
+    console.log("Rebar initialization complete!");
+    console.log();
+    console.log("Next steps:");
+    console.log("  rebar doctor        Check setup health");
+    console.log("  rebar audit         Run quality audit");
+    console.log();
+    return 0;
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+
+async function cmdDoctor(options: CLIOptions): Promise<number> {
+  const projectPath = resolveProjectPath(options.path);
+
+  interface Check {
+    name: string;
+    status: "PASS" | "WARN" | "FAIL";
+    message: string;
+    details?: string[];
+  }
+
+  const checks: Check[] = [];
+
+  try {
+    // Check 1: CLAUDE.md
+    const claudemd = await readFileSafe(path.join(projectPath, "CLAUDE.md"));
+    if (!claudemd) {
+      checks.push({ name: "CLAUDE.md", status: "FAIL", message: "Not found", details: ["Run: rebar init"] });
+    } else {
+      const validation = validateClaudeMD(claudemd, "CLAUDE.md");
+      if (validation.errors.length > 0) {
+        checks.push({ name: "CLAUDE.md", status: "FAIL", message: "Invalid", details: validation.errors });
+      } else {
+        checks.push({ name: "CLAUDE.md", status: "PASS", message: "Present and valid" });
+      }
+    }
+
+    // Check 2: Settings/Hooks
+    const settings = await readFileSafe(path.join(projectPath, ".claude/settings.json"));
+    if (!settings) {
+      checks.push({ name: "Hooks", status: "FAIL", message: "No settings.json", details: ["Run: rebar init"] });
+    } else {
+      const parsed = validateJSON(settings, "settings.json");
+      if (!parsed.valid) {
+        checks.push({ name: "Hooks", status: "FAIL", message: "Invalid JSON", details: parsed.errors });
+      } else {
+        const s = parsed.parsed as Record<string, unknown>;
+        const hooks = s.hooks as Record<string, unknown[]> | undefined;
+        if (!hooks || Object.keys(hooks).length === 0) {
+          checks.push({ name: "Hooks", status: "WARN", message: "No hooks configured" });
+        } else {
+          const count = Object.values(hooks).reduce((sum, arr) => sum + arr.length, 0);
+          checks.push({ name: "Hooks", status: "PASS", message: `${count} hook(s) installed` });
+        }
+      }
+    }
+
+    // Check 3: Skills
+    const skillsDir = path.join(projectPath, ".claude/skills");
+    const skillFiles = await listFilesRecursive(skillsDir, ".md");
+    if (skillFiles.length === 0) {
+      checks.push({ name: "Skills", status: "WARN", message: "None installed (optional)" });
+    } else {
+      checks.push({ name: "Skills", status: "PASS", message: `${skillFiles.length} skill(s)` });
+    }
+
+    // Check 4: .claudeignore
+    if (await fileExists(path.join(projectPath, ".claudeignore"))) {
+      checks.push({ name: ".claudeignore", status: "PASS", message: "Present" });
+    } else {
+      checks.push({ name: ".claudeignore", status: "WARN", message: "Not found (recommended)" });
+    }
+
+    // Check 5: Strictness profile
+    if (settings) {
+      const parsed = validateJSON(settings, "settings.json");
+      if (parsed.valid && parsed.parsed) {
+        const s = parsed.parsed as Record<string, unknown>;
+        const hooks = s.hooks as Record<string, unknown[]> | undefined;
+        if (hooks) {
+          const profile = detectCurrentProfile(hooks);
+          if (profile) {
+            checks.push({ name: "Strictness", status: "PASS", message: `Profile: ${profile}` });
+          } else {
+            checks.push({ name: "Strictness", status: "WARN", message: "Custom/mixed config" });
+          }
+        }
+      }
+    }
+
+    // Check 6: Context budget
+    let totalTokens = 0;
+    if (claudemd) totalTokens += estimateTokens(claudemd);
+    for (const sf of skillFiles) {
+      const content = await readFileSafe(sf);
+      if (content) totalTokens += estimateTokens(content);
+    }
+    const budgetPercent = (totalTokens / CONTEXT_WINDOW_TOKENS) * 100;
+    if (budgetPercent > 10) {
+      checks.push({ name: "Context", status: "FAIL", message: `${budgetPercent.toFixed(1)}% (>10%)` });
+    } else if (budgetPercent > 5) {
+      checks.push({ name: "Context", status: "WARN", message: `${budgetPercent.toFixed(1)}% (target <5%)` });
+    } else {
+      checks.push({ name: "Context", status: "PASS", message: `${budgetPercent.toFixed(1)}%` });
+    }
+
+    // Output
+    const passCount = checks.filter(c => c.status === "PASS").length;
+    const warnCount = checks.filter(c => c.status === "WARN").length;
+    const failCount = checks.filter(c => c.status === "FAIL").length;
+
+    if (options.format === "json") {
+      console.log(JSON.stringify({
+        overall: failCount === 0 ? (warnCount === 0 ? "Healthy" : "Needs Attention") : "Broken",
+        summary: { pass: passCount, warn: warnCount, fail: failCount },
+        checks,
+      }, null, 2));
+    } else {
+      console.log("Rebar Doctor Report");
+      console.log("===================");
+      console.log();
+
+      for (const check of checks) {
+        const icon = check.status === "PASS" ? "✓" : check.status === "WARN" ? "⚠" : "✗";
+        console.log(`${icon} ${check.name}: ${check.message}`);
+        if (check.details) {
+          for (const d of check.details) {
+            console.log(`    ${d}`);
+          }
+        }
+      }
+
+      console.log();
+      const overall = failCount === 0 ? (warnCount === 0 ? "✓ Healthy" : "⚠ Needs Attention") : "✗ Broken";
+      console.log(`Overall: ${overall} (${passCount} pass, ${warnCount} warn, ${failCount} fail)`);
+    }
+
+    return failCount > 0 ? 1 : 0;
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+
+async function cmdAudit(options: CLIOptions): Promise<number> {
+  const projectPath = resolveProjectPath(options.path);
+
+  interface AuditResult {
+    category: string;
+    score: number;
+    maxScore: number;
+    issues: string[];
+  }
+
+  const results: AuditResult[] = [];
+
+  try {
+    // 1. CLAUDE.md quality (25 points)
+    const claudemd = await readFileSafe(path.join(projectPath, "CLAUDE.md"));
+    const claudemdResult: AuditResult = { category: "CLAUDE.md", score: 0, maxScore: 25, issues: [] };
+    if (claudemd) {
+      claudemdResult.score += 10; // Exists
+      if (validateClaudeMD(claudemd, "CLAUDE.md").valid) claudemdResult.score += 5;
+      if (/##\s*(Build|Test)/i.test(claudemd)) claudemdResult.score += 5;
+      if (/##\s*(Architecture)/i.test(claudemd)) claudemdResult.score += 5;
+    } else {
+      claudemdResult.issues.push("No CLAUDE.md found");
+    }
+    results.push(claudemdResult);
+
+    // 2. Enforcement hooks (25 points)
+    const settings = await readFileSafe(path.join(projectPath, ".claude/settings.json"));
+    const hooksResult: AuditResult = { category: "Enforcement", score: 0, maxScore: 25, issues: [] };
+    if (settings) {
+      const parsed = validateJSON(settings, "settings.json");
+      if (parsed.valid && parsed.parsed) {
+        const s = parsed.parsed as Record<string, unknown>;
+        const hooks = s.hooks as Record<string, unknown[]> | undefined;
+        if (hooks) {
+          hooksResult.score += 10; // Has hooks
+          const profile = detectCurrentProfile(hooks);
+          if (profile === "standard") hooksResult.score += 5;
+          if (profile === "strict") hooksResult.score += 10;
+          if (profile === "paranoid") hooksResult.score += 15;
+          if (hooks.PreToolCall || hooks.PostToolCall) hooksResult.score += 0; // Already counted
+        } else {
+          hooksResult.issues.push("No hooks configured");
+        }
+      } else {
+        hooksResult.issues.push("Invalid settings.json");
+      }
+    } else {
+      hooksResult.issues.push("No settings.json found");
+    }
+    results.push(hooksResult);
+
+    // 3. Skills quality (20 points)
+    const skillsDir = path.join(projectPath, ".claude/skills");
+    const skillFiles = await listFilesRecursive(skillsDir, ".md");
+    const skillsResult: AuditResult = { category: "Skills", score: 0, maxScore: 20, issues: [] };
+    if (skillFiles.length > 0) {
+      skillsResult.score += 10;
+      let validSkills = 0;
+      for (const sf of skillFiles) {
+        const content = await readFileSafe(sf);
+        if (content && validateSkillFrontmatter(content).valid) {
+          validSkills++;
+        }
+      }
+      if (validSkills === skillFiles.length) {
+        skillsResult.score += 10;
+      } else {
+        skillsResult.issues.push(`${skillFiles.length - validSkills} skill(s) have invalid frontmatter`);
+      }
+    } else {
+      skillsResult.score += 10; // Skills are optional, don't penalize heavily
+    }
+    results.push(skillsResult);
+
+    // 4. Context budget (15 points)
+    const contextResult: AuditResult = { category: "Context Budget", score: 0, maxScore: 15, issues: [] };
+    let totalTokens = 0;
+    if (claudemd) totalTokens += estimateTokens(claudemd);
+    for (const sf of skillFiles) {
+      const content = await readFileSafe(sf);
+      if (content) totalTokens += estimateTokens(content);
+    }
+    const budgetPercent = (totalTokens / CONTEXT_WINDOW_TOKENS) * 100;
+    if (budgetPercent <= 2) {
+      contextResult.score = 15;
+    } else if (budgetPercent <= 5) {
+      contextResult.score = 10;
+    } else if (budgetPercent <= 10) {
+      contextResult.score = 5;
+      contextResult.issues.push(`Config uses ${budgetPercent.toFixed(1)}% of context`);
+    } else {
+      contextResult.issues.push(`Config uses ${budgetPercent.toFixed(1)}% (too high)`);
+    }
+    results.push(contextResult);
+
+    // 5. Best practices (15 points)
+    const practicesResult: AuditResult = { category: "Best Practices", score: 0, maxScore: 15, issues: [] };
+    if (await fileExists(path.join(projectPath, ".claudeignore"))) {
+      practicesResult.score += 5;
+    } else {
+      practicesResult.issues.push("No .claudeignore");
+    }
+    if (await fileExists(path.join(projectPath, ".claude/agents"))) {
+      const agents = await listFiles(path.join(projectPath, ".claude/agents"), ".md");
+      if (agents.length > 0) practicesResult.score += 5;
+    }
+    if (await fileExists(path.join(projectPath, ".claude/docs"))) {
+      practicesResult.score += 5;
+    }
+    results.push(practicesResult);
+
+    // Calculate total
+    const totalScore = results.reduce((sum, r) => sum + r.score, 0);
+    const maxScore = results.reduce((sum, r) => sum + r.maxScore, 0);
+    const percentage = Math.round((totalScore / maxScore) * 100);
+
+    // Output
+    if (options.format === "json") {
+      console.log(JSON.stringify({
+        score: percentage,
+        total: totalScore,
+        maxScore,
+        categories: results,
+        pass: options.threshold === 0 || percentage >= options.threshold,
+      }, null, 2));
+    } else {
+      console.log("Rebar Quality Audit");
+      console.log("===================");
+      console.log();
+
+      for (const r of results) {
+        const bar = "█".repeat(Math.round(r.score / r.maxScore * 10)) +
+                    "░".repeat(10 - Math.round(r.score / r.maxScore * 10));
+        console.log(`${r.category.padEnd(16)} ${bar} ${r.score}/${r.maxScore}`);
+        for (const issue of r.issues) {
+          console.log(`                   ⚠ ${issue}`);
+        }
+      }
+
+      console.log();
+      console.log(`Overall Score: ${percentage}/100`);
+
+      if (options.threshold > 0) {
+        if (percentage >= options.threshold) {
+          console.log(`✓ Passed threshold (${options.threshold})`);
+        } else {
+          console.log(`✗ Below threshold (${options.threshold})`);
+        }
+      }
+    }
+
+    if (options.threshold > 0 && percentage < options.threshold) {
+      return 1;
+    }
+    return 0;
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+
+async function cmdSetStrictness(options: CLIOptions, level: string): Promise<number> {
+  const projectPath = resolveProjectPath(options.path);
+
+  if (level !== "standard" && level !== "strict" && level !== "paranoid") {
+    console.error(`Invalid strictness level: ${level}`);
+    console.error("Valid levels: standard, strict, paranoid");
+    return 1;
+  }
+
+  try {
+    // Detect test/lint/format commands
+    const analysis = await analyzeProject(projectPath);
+    const testCmd = Object.values(analysis.testCommands)[0] || "npm test";
+    const lintCmd = analysis.linter ? `npx ${analysis.linter.toLowerCase()} .` : "npm run lint";
+    const formatCmd = analysis.formatter ? `npx ${analysis.formatter.toLowerCase()} --write .` : "npm run format";
+
+    // Generate hooks for profile
+    const hooks = getHooksForProfile(level, testCmd, lintCmd, formatCmd);
+
+    // Read existing settings or create new
+    const settingsPath = path.join(projectPath, ".claude/settings.json");
+    let existingSettings: Record<string, unknown> = {};
+    const settingsContent = await readFileSafe(settingsPath);
+    if (settingsContent) {
+      try {
+        existingSettings = JSON.parse(settingsContent) as Record<string, unknown>;
+      } catch {
+        // Start fresh
+      }
+    }
+
+    // Merge hooks into settings
+    existingSettings.hooks = hooksToSettingsFormat(hooks);
+
+    // Ensure directory exists
+    await fs.mkdir(path.join(projectPath, ".claude"), { recursive: true });
+
+    // Write settings
+    await atomicWrite(settingsPath, JSON.stringify(existingSettings, null, 2));
+
+    console.log(`✓ Strictness set to: ${level}`);
+    console.log();
+    console.log("Installed hooks:");
+    for (const hook of hooks) {
+      // Determine if hook blocks based on command contents
+      const isBlocking = hook.command.includes("exit 2");
+      const behavior = isBlocking ? "blocks" : "notifies";
+      console.log(`  • ${hook.event}: ${hook.description} (${behavior})`);
+    }
+
+    return 0;
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+
+async function cmdMetrics(options: CLIOptions): Promise<number> {
+  const projectPath = resolveProjectPath(options.path);
+
+  // Metrics are stored in .rebar/metrics.json
+  const metricsPath = path.join(projectPath, ".rebar/metrics.json");
+  const metricsContent = await readFileSafe(metricsPath);
+
+  if (!metricsContent) {
+    console.log("No metrics history found.");
+    console.log("Run 'rebar audit' to generate metrics.");
+    return 0;
+  }
+
+  try {
+    const metrics = JSON.parse(metricsContent) as Array<{
+      timestamp: string;
+      score: number;
+      categories: Record<string, number>;
+    }>;
+
+    if (options.format === "json") {
+      console.log(JSON.stringify(metrics, null, 2));
+    } else {
+      console.log("Rebar Quality Metrics History");
+      console.log("=============================");
+      console.log();
+
+      for (const m of metrics.slice(-10)) { // Last 10 entries
+        const date = new Date(m.timestamp).toLocaleDateString();
+        const bar = "█".repeat(Math.round(m.score / 10)) + "░".repeat(10 - Math.round(m.score / 10));
+        console.log(`${date}  ${bar} ${m.score}/100`);
+      }
+    }
+
+    return 0;
+  } catch (err) {
+    console.error(`Error parsing metrics: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+
+async function cmdBadge(options: CLIOptions): Promise<number> {
+  const projectPath = resolveProjectPath(options.path);
+
+  // Run audit to get current score
+  let score = 0;
+  try {
+    const claudemd = await readFileSafe(path.join(projectPath, "CLAUDE.md"));
+    const settings = await readFileSafe(path.join(projectPath, ".claude/settings.json"));
+
+    // Quick score calculation
+    if (claudemd) score += 25;
+    if (settings) {
+      const parsed = validateJSON(settings, "settings.json");
+      if (parsed.valid) {
+        const s = parsed.parsed as Record<string, unknown>;
+        if (s.hooks && Object.keys(s.hooks as object).length > 0) {
+          score += 25;
+        }
+      }
+    }
+    if (await fileExists(path.join(projectPath, ".claudeignore"))) score += 15;
+    if (await fileExists(path.join(projectPath, ".claude/skills"))) score += 15;
+    score += 20; // Base context budget score
+  } catch {
+    // Use score of 0
+  }
+
+  // Determine color
+  let color: string;
+  let label: string;
+  if (score >= 80) {
+    color = "#4c1"; // Green
+    label = "excellent";
+  } else if (score >= 60) {
+    color = "#97ca00"; // Yellow-green
+    label = "good";
+  } else if (score >= 40) {
+    color = "#dfb317"; // Yellow
+    label = "fair";
+  } else {
+    color = "#e05d44"; // Red
+    label = "needs work";
+  }
+
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="120" height="20">
+  <linearGradient id="b" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="a">
+    <rect width="120" height="20" rx="3" fill="#fff"/>
+  </clipPath>
+  <g clip-path="url(#a)">
+    <path fill="#555" d="M0 0h55v20H0z"/>
+    <path fill="${color}" d="M55 0h65v20H55z"/>
+    <path fill="url(#b)" d="M0 0h120v20H0z"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
+    <text x="27.5" y="15" fill="#010101" fill-opacity=".3">rebar</text>
+    <text x="27.5" y="14">rebar</text>
+    <text x="87.5" y="15" fill="#010101" fill-opacity=".3">${score}/100</text>
+    <text x="87.5" y="14">${score}/100</text>
+  </g>
+</svg>`;
+
+  if (options.format === "json") {
+    console.log(JSON.stringify({ score, label, color, svg }, null, 2));
+  } else {
+    // Write SVG file
+    const badgePath = path.join(projectPath, ".rebar/badge.svg");
+    await fs.mkdir(path.join(projectPath, ".rebar"), { recursive: true });
+    await atomicWrite(badgePath, svg);
+    console.log(`✓ Badge generated: ${badgePath}`);
+    console.log(`  Score: ${score}/100 (${label})`);
+    console.log();
+    console.log("Add to README.md:");
+    console.log("  ![Rebar Score](.rebar/badge.svg)");
+  }
+
+  return 0;
+}
+
+export async function runCLI(args: string[]): Promise<number> {
+  const { command, options, positional } = parseArgs(args);
+
+  switch (command) {
+    case "init":
+      return cmdInit(options);
+
+    case "doctor":
+      return cmdDoctor(options);
+
+    case "audit":
+      return cmdAudit(options);
+
+    case "set-strictness":
+      if (positional.length === 0) {
+        console.error("Usage: rebar set-strictness <standard|strict|paranoid>");
+        return 1;
+      }
+      return cmdSetStrictness(options, positional[0]);
+
+    case "metrics":
+      return cmdMetrics(options);
+
+    case "badge":
+      return cmdBadge(options);
+
+    case "version":
+    case "--version":
+    case "-v":
+      console.log(`rebar-mcp v${VERSION}`);
+      return 0;
+
+    case "help":
+    case "--help":
+    case "-h":
+    case "":
+      console.log(`Rebar — Reinforcement for AI-generated code
+
+Usage:
+  rebar init [options]          Initialize Rebar enforcement in a project
+  rebar audit [options]         Run quality audit (exit 1 if below threshold)
+  rebar doctor [options]        Check Rebar setup health
+  rebar set-strictness <level>  Change enforcement strictness
+  rebar metrics [options]       View quality score history
+  rebar badge [options]         Generate quality score badge SVG
+  rebar version                 Print version
+  rebar help                    Show this help
+
+Options:
+  --path <dir>          Project path (default: current directory)
+  --strictness <level>  standard | strict | paranoid (default: standard)
+  --platforms <list>    claude-code,cursor,windsurf,codex,all (default: all)
+  --format <type>       markdown | json (default: markdown)
+  --threshold <score>   Minimum quality score for audit (exits 1 if below)
+
+Examples:
+  rebar init --strictness strict --platforms all
+  rebar audit --threshold 80 --format json
+  rebar doctor
+  npx rebar-mcp audit --threshold 70    # CI/CD usage
+
+Strictness Levels:
+  standard  - Notify on issues (tests, lint, secrets)
+  strict    - Block on test/lint failures
+  paranoid  - Block + file size limits + TODO guards`);
+      return 0;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.error("Run 'rebar help' for usage information.");
+      return 1;
+  }
+}