rebar-mcp 2.0.0

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function runCLI(args: string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAspBA,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAwE5D"}

package/dist/cli.js

@@ -0,0 +1,674 @@
+#!/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, readFileSafe, fileExists, listFiles, listFilesRecursive, } from "./services/file-ops.js";
+import { validateClaudeMD, validateSkillFrontmatter, validateJSON, estimateTokens } from "./services/validation.js";
+import { detectCurrentProfile, getHooksForProfile, hooksToSettingsFormat } 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";
+function parseArgs(args) {
+    const options = {
+        path: ".",
+        strictness: "standard",
+        platforms: ["all"],
+        format: "markdown",
+        threshold: 0,
+    };
+    const positional = [];
+    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) {
+    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) {
+    const projectPath = resolveProjectPath(options.path);
+    const checks = [];
+    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;
+                const hooks = s.hooks;
+                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;
+                const hooks = s.hooks;
+                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) {
+    const projectPath = resolveProjectPath(options.path);
+    const results = [];
+    try {
+        // 1. CLAUDE.md quality (25 points)
+        const claudemd = await readFileSafe(path.join(projectPath, "CLAUDE.md"));
+        const claudemdResult = { 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 = { category: "Enforcement", score: 0, maxScore: 25, issues: [] };
+        if (settings) {
+            const parsed = validateJSON(settings, "settings.json");
+            if (parsed.valid && parsed.parsed) {
+                const s = parsed.parsed;
+                const hooks = s.hooks;
+                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 = { 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 = { 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 = { 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, level) {
+    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 = {};
+        const settingsContent = await readFileSafe(settingsPath);
+        if (settingsContent) {
+            try {
+                existingSettings = JSON.parse(settingsContent);
+            }
+            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) {
+    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);
+        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) {
+    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;
+                if (s.hooks && Object.keys(s.hooks).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;
+    let label;
+    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) {
+    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;
+    }
+}
+//# sourceMappingURL=cli.js.map