rebar-mcp 2.0.0

package/dist/tools/management.js

@@ -0,0 +1,1541 @@
+import * as path from "node:path";
+import { ListArtifactsInputSchema, ValidateConfigInputSchema, AuditContextInputSchema, DoctorInputSchema, MetricsInputSchema, BadgeInputSchema, CustomRulesInputSchema, } from "../schemas/scaffolding.js";
+import { loadCustomRules, evaluateAllRules, generateDefaultRulesTemplate, } from "../services/rules-engine.js";
+import { detectCurrentProfile } from "../services/strictness.js";
+import { resolveProjectPath, sanitizePath, atomicWrite, readFileSafe, listFiles, listFilesRecursive, fileExists, } from "../services/file-ops.js";
+import { validateSkillFrontmatter, validateJSON, validateClaudeMD, estimateTokens, } from "../services/validation.js";
+import { CONTEXT_WINDOW_TOKENS, SKILL_BUDGET_PERCENT, CLAUDEMD_MAX_LINES } from "../constants.js";
+function makeResult(text, isError = false) {
+    return {
+        content: [{ type: "text", text }],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+export function registerManagementTools(server) {
+    // ─── rebar_list_artifacts ────────────────────────────────────────
+    server.registerTool("rebar_list_artifacts", {
+        title: "List Artifacts",
+        description: "[Rebar] Lists all Claude Code configuration artifacts in the project with type, location, " +
+            "validation status, and issue details. Supports filtering by artifact type.\n\n" +
+            "Artifact types discovered:\n" +
+            "• claudemd: CLAUDE.md files (root and subdirectory)\n" +
+            "• skill: Skills in .claude/skills/\n" +
+            "• agent: Subagents in .claude/agents/\n" +
+            "• hook: Hooks in .claude/settings.json\n" +
+            "• knowledge: Docs in .claude/docs/\n" +
+            "• mcp-config: .mcp.json configuration\n" +
+            "• settings: .claude/settings.json\n\n" +
+            "Examples:\n" +
+            "  rebar_list_artifacts({ project_path: '.' })\n" +
+            "  rebar_list_artifacts({ project_path: '.', type_filter: 'skill' })\n" +
+            "  rebar_list_artifacts({ project_path: '.', type_filter: 'hook' })\n\n" +
+            "Returns: Formatted list with validation status per artifact.\n" +
+            "Error: If project_path doesn't exist.",
+        inputSchema: ListArtifactsInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        const { project_path, type_filter } = args;
+        const absPath = resolveProjectPath(project_path);
+        const artifacts = [];
+        try {
+            // ── CLAUDE.md ───────────────────────────────────────────
+            if (type_filter === "all" || type_filter === "claudemd") {
+                // Check root CLAUDE.md
+                const claudemdPath = sanitizePath(absPath, "CLAUDE.md");
+                if (await fileExists(claudemdPath)) {
+                    const content = await readFileSafe(claudemdPath);
+                    if (content) {
+                        const validation = validateClaudeMD(content, claudemdPath);
+                        artifacts.push({
+                            type: "claudemd",
+                            name: "CLAUDE.md (root)",
+                            path: claudemdPath,
+                            valid: validation.valid,
+                            issues: [...validation.errors, ...validation.warnings],
+                        });
+                    }
+                }
+                // Check for subdirectory CLAUDE.md files
+                for (const subdir of ["apps", "packages", "services", "libs"]) {
+                    const subdirPath = path.join(absPath, subdir);
+                    if (await fileExists(subdirPath)) {
+                        const subClaudeMds = await listFilesRecursive(subdirPath, "CLAUDE.md");
+                        // listFilesRecursive matches by extension, but CLAUDE.md has .md extension
+                        // Filter to only actual CLAUDE.md files
+                        for (const md of subClaudeMds) {
+                            if (path.basename(md) === "CLAUDE.md") {
+                                const content = await readFileSafe(md);
+                                const relPath = path.relative(absPath, md);
+                                if (content) {
+                                    const validation = validateClaudeMD(content, md);
+                                    artifacts.push({
+                                        type: "claudemd",
+                                        name: `CLAUDE.md (${relPath})`,
+                                        path: md,
+                                        valid: validation.valid,
+                                        issues: [...validation.errors, ...validation.warnings],
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // ── Skills ──────────────────────────────────────────────
+            if (type_filter === "all" || type_filter === "skill") {
+                const skillsDir = sanitizePath(absPath, ".claude/skills");
+                const skillFiles = await listFilesRecursive(skillsDir, ".md");
+                for (const sf of skillFiles) {
+                    const content = await readFileSafe(sf);
+                    if (content) {
+                        const validation = validateSkillFrontmatter(content);
+                        const skillName = path.basename(path.dirname(sf));
+                        const tokens = estimateTokens(content);
+                        artifacts.push({
+                            type: "skill",
+                            name: `${skillName} (~${tokens} tokens)`,
+                            path: sf,
+                            valid: validation.valid,
+                            issues: validation.errors,
+                        });
+                    }
+                }
+            }
+            // ── Agents ──────────────────────────────────────────────
+            if (type_filter === "all" || type_filter === "agent") {
+                const agentsDir = sanitizePath(absPath, ".claude/agents");
+                const agentFiles = await listFiles(agentsDir, ".md");
+                for (const af of agentFiles) {
+                    const content = await readFileSafe(af);
+                    const tokens = content ? estimateTokens(content) : 0;
+                    artifacts.push({
+                        type: "agent",
+                        name: `${path.basename(af, ".md")} (~${tokens} tokens)`,
+                        path: af,
+                        valid: true,
+                        issues: [],
+                    });
+                }
+            }
+            // ── Hooks ───────────────────────────────────────────────
+            if (type_filter === "all" || type_filter === "hook") {
+                const settingsPath = sanitizePath(absPath, ".claude/settings.json");
+                const settingsContent = await readFileSafe(settingsPath);
+                if (settingsContent) {
+                    const validation = validateJSON(settingsContent, "settings.json");
+                    if (validation.valid && validation.parsed && typeof validation.parsed === "object") {
+                        const settings = validation.parsed;
+                        if (settings.hooks && typeof settings.hooks === "object") {
+                            const hooks = settings.hooks;
+                            for (const [event, hookList] of Object.entries(hooks)) {
+                                if (Array.isArray(hookList)) {
+                                    for (const hook of hookList) {
+                                        const h = hook;
+                                        artifacts.push({
+                                            type: "hook",
+                                            name: `[${event}] ${String(h.description || h.command || "unnamed")}`,
+                                            path: settingsPath,
+                                            valid: true,
+                                            issues: [],
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // ── Knowledge ───────────────────────────────────────────
+            if (type_filter === "all" || type_filter === "knowledge") {
+                const docsDir = sanitizePath(absPath, ".claude/docs");
+                const docFiles = await listFilesRecursive(docsDir, ".md");
+                for (const df of docFiles) {
+                    const relPath = path.relative(absPath, df);
+                    const tokens = (await readFileSafe(df))?.length ?? 0;
+                    artifacts.push({
+                        type: "knowledge",
+                        name: `${path.basename(df, ".md")} (~${estimateTokens(String(tokens))} tokens)`,
+                        path: df,
+                        valid: true,
+                        issues: [],
+                    });
+                }
+            }
+            // ── MCP Config ──────────────────────────────────────────
+            if (type_filter === "all" || type_filter === "mcp-config") {
+                const mcpPath = sanitizePath(absPath, ".mcp.json");
+                if (await fileExists(mcpPath)) {
+                    const content = await readFileSafe(mcpPath);
+                    if (content) {
+                        const validation = validateJSON(content, ".mcp.json");
+                        let serverCount = 0;
+                        if (validation.valid && validation.parsed && typeof validation.parsed === "object") {
+                            const cfg = validation.parsed;
+                            if (cfg.mcpServers && typeof cfg.mcpServers === "object") {
+                                serverCount = Object.keys(cfg.mcpServers).length;
+                            }
+                        }
+                        artifacts.push({
+                            type: "mcp-config",
+                            name: `.mcp.json (${serverCount} server${serverCount !== 1 ? "s" : ""})`,
+                            path: mcpPath,
+                            valid: validation.valid,
+                            issues: validation.errors,
+                        });
+                    }
+                }
+            }
+            // ── Settings ────────────────────────────────────────────
+            if (type_filter === "all" || type_filter === "settings") {
+                const settingsPath = sanitizePath(absPath, ".claude/settings.json");
+                if (await fileExists(settingsPath)) {
+                    const content = await readFileSafe(settingsPath);
+                    if (content) {
+                        const validation = validateJSON(content, "settings.json");
+                        artifacts.push({
+                            type: "settings",
+                            name: ".claude/settings.json",
+                            path: settingsPath,
+                            valid: validation.valid,
+                            issues: validation.errors,
+                        });
+                    }
+                }
+            }
+            if (artifacts.length === 0) {
+                return makeResult(`No Claude Code artifacts found in ${absPath}\n\n` +
+                    `This project hasn't been configured for Claude Code yet.\n` +
+                    `Run rebar_init_project to set up a complete configuration.\n\n` +
+                    `Or create individual artifacts:\n` +
+                    `• rebar_generate_claudemd — Create a CLAUDE.md\n` +
+                    `• rebar_create_skill — Add a skill\n` +
+                    `• rebar_create_hook — Add a lifecycle hook`);
+            }
+            // Group by type for better readability
+            const byType = new Map();
+            for (const a of artifacts) {
+                const list = byType.get(a.type) || [];
+                list.push(a);
+                byType.set(a.type, list);
+            }
+            const validCount = artifacts.filter((a) => a.valid).length;
+            const invalidCount = artifacts.length - validCount;
+            let output = `Found ${artifacts.length} artifact${artifacts.length !== 1 ? "s" : ""} in ${absPath}`;
+            if (invalidCount > 0) {
+                output += ` (${invalidCount} with issues)`;
+            }
+            output += "\n\n";
+            for (const [type, items] of byType) {
+                output += `── ${type.toUpperCase()} (${items.length}) ──\n`;
+                for (const item of items) {
+                    const status = item.valid ? "OK" : "!!";
+                    output += `  [${status}] ${item.name}\n`;
+                    output += `       ${item.path}\n`;
+                    if (item.issues.length > 0) {
+                        for (const issue of item.issues) {
+                            output += `       ⚠ ${issue}\n`;
+                        }
+                    }
+                }
+                output += "\n";
+            }
+            return makeResult(output.trimEnd());
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return makeResult(`Failed to list artifacts: ${message}`, true);
+        }
+    });
+    // ─── rebar_validate_config ───────────────────────────────────────
+    server.registerTool("rebar_validate_config", {
+        title: "Validate Configuration",
+        description: "[Rebar] Deep validation of all Claude Code configuration files. Catches real problems " +
+            "before they cause confusing behavior in Claude Code sessions.\n\n" +
+            "Checks performed:\n" +
+            "• CLAUDE.md: Exists, not empty, starts with heading, under 500 lines\n" +
+            "• Skills: Valid YAML frontmatter, required 'name' and 'description' fields, " +
+            "name under 64 chars, description under 200 chars\n" +
+            "• Settings: Valid JSON, proper hook structure\n" +
+            "• .mcp.json: Valid JSON structure\n" +
+            "• Agents: Files exist and are readable\n\n" +
+            "auto_fix mode can repair:\n" +
+            "• Trailing commas in JSON\n" +
+            "• Missing frontmatter fields (adds placeholders)\n\n" +
+            "Examples:\n" +
+            "  rebar_validate_config({ project_path: '.', fix_mode: 'report' })\n" +
+            "  rebar_validate_config({ project_path: '.', fix_mode: 'auto_fix' })\n\n" +
+            "Returns: Validation report with errors, warnings, and applied fixes.",
+        inputSchema: ValidateConfigInputSchema,
+        annotations: {
+            readOnlyHint: false, // can write in auto_fix mode
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        const { project_path, fix_mode } = args;
+        const absPath = resolveProjectPath(project_path);
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        try {
+            // ── CLAUDE.md validation ────────────────────────────────
+            const claudemdPath = sanitizePath(absPath, "CLAUDE.md");
+            const claudemd = await readFileSafe(claudemdPath);
+            if (claudemd) {
+                const result = validateClaudeMD(claudemd, claudemdPath);
+                errors.push(...result.errors);
+                warnings.push(...result.warnings);
+                // Additional deep checks
+                const lines = claudemd.split("\n");
+                if (lines.length > CLAUDEMD_MAX_LINES) {
+                    warnings.push(`CLAUDE.md has ${lines.length} lines (recommended max: ${CLAUDEMD_MAX_LINES}). ` +
+                        `Consider splitting into subdirectory CLAUDE.md files.`);
+                }
+                // Check for common issues
+                if (claudemd.includes("TODO") || claudemd.includes("FIXME")) {
+                    warnings.push("CLAUDE.md contains TODO/FIXME markers — consider resolving them");
+                }
+                if (!claudemd.includes("## Build") && !claudemd.includes("## Test")) {
+                    warnings.push("CLAUDE.md is missing Build & Test section — Claude won't know how to build your project");
+                }
+            }
+            else {
+                errors.push("No CLAUDE.md found — Claude Code works significantly better with one");
+            }
+            // ── Skill validation ────────────────────────────────────
+            const skillsDir = sanitizePath(absPath, ".claude/skills");
+            const skillFiles = await listFilesRecursive(skillsDir, ".md");
+            for (const sf of skillFiles) {
+                const content = await readFileSafe(sf);
+                if (!content)
+                    continue;
+                const result = validateSkillFrontmatter(content);
+                if (!result.valid) {
+                    for (const err of result.errors) {
+                        errors.push(`${path.relative(absPath, sf)}: ${err}`);
+                    }
+                    // Auto-fix: add missing frontmatter
+                    if (fix_mode === "auto_fix") {
+                        const fm = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+                        if (!fm) {
+                            // No frontmatter at all — add it
+                            const skillName = path.basename(path.dirname(sf));
+                            const fixed = `---\nname: ${skillName}\ndescription: TODO - add description\ninvocation: user\ncontext: inline\n---\n\n${content}`;
+                            await atomicWrite(sf, fixed);
+                            fixes.push(`Added missing frontmatter to ${path.relative(absPath, sf)}`);
+                        }
+                    }
+                }
+                // Check token budget
+                const tokens = estimateTokens(content);
+                if (tokens > 1000) {
+                    warnings.push(`${path.relative(absPath, sf)}: Skill is large (~${tokens} tokens). ` +
+                        `Skills should be concise to minimize context window usage.`);
+                }
+            }
+            // ── Settings validation ─────────────────────────────────
+            const settingsPath = sanitizePath(absPath, ".claude/settings.json");
+            const settingsContent = await readFileSafe(settingsPath);
+            if (settingsContent) {
+                const result = validateJSON(settingsContent, ".claude/settings.json");
+                if (!result.valid) {
+                    errors.push(...result.errors);
+                    if (fix_mode === "auto_fix") {
+                        try {
+                            const cleaned = settingsContent
+                                .replace(/,\s*}/g, "}")
+                                .replace(/,\s*]/g, "]");
+                            JSON.parse(cleaned);
+                            await atomicWrite(settingsPath, cleaned);
+                            fixes.push("Fixed JSON syntax in .claude/settings.json");
+                        }
+                        catch {
+                            // Can't auto-fix this
+                        }
+                    }
+                }
+                else if (result.parsed) {
+                    // Validate hook structure
+                    const settings = result.parsed;
+                    if (settings.hooks && typeof settings.hooks === "object") {
+                        const hooks = settings.hooks;
+                        for (const [event, hookList] of Object.entries(hooks)) {
+                            if (!Array.isArray(hookList)) {
+                                errors.push(`Hook event "${event}" should be an array, got ${typeof hookList}`);
+                            }
+                            else {
+                                for (let i = 0; i < hookList.length; i++) {
+                                    const h = hookList[i];
+                                    if (!h.command) {
+                                        errors.push(`Hook ${event}[${i}] missing required "command" field`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // ── .mcp.json validation ────────────────────────────────
+            const mcpPath = sanitizePath(absPath, ".mcp.json");
+            const mcpContent = await readFileSafe(mcpPath);
+            if (mcpContent) {
+                const result = validateJSON(mcpContent, ".mcp.json");
+                if (!result.valid) {
+                    errors.push(...result.errors);
+                }
+                else if (result.parsed) {
+                    const cfg = result.parsed;
+                    if (!cfg.mcpServers) {
+                        warnings.push(".mcp.json missing 'mcpServers' key — file may not be recognized");
+                    }
+                }
+            }
+            // ── Results ─────────────────────────────────────────────
+            const totalIssues = errors.length + warnings.length;
+            const status = errors.length === 0 ? "PASSED" : "FAILED";
+            let output = `Validation: ${status}\n`;
+            output += `Checked: CLAUDE.md, ${skillFiles.length} skill(s), settings.json, .mcp.json\n\n`;
+            if (errors.length > 0) {
+                output += `ERRORS (${errors.length}):\n`;
+                for (const e of errors) {
+                    output += `  ✗ ${e}\n`;
+                }
+                output += "\n";
+            }
+            if (warnings.length > 0) {
+                output += `WARNINGS (${warnings.length}):\n`;
+                for (const w of warnings) {
+                    output += `  ⚠ ${w}\n`;
+                }
+                output += "\n";
+            }
+            if (fixes.length > 0) {
+                output += `FIXES APPLIED (${fixes.length}):\n`;
+                for (const f of fixes) {
+                    output += `  ✓ ${f}\n`;
+                }
+                output += "\n";
+            }
+            if (totalIssues === 0) {
+                output += "All configuration files are valid and well-structured.";
+            }
+            else if (errors.length > 0 && fix_mode === "report") {
+                output += `Run with fix_mode: "auto_fix" to automatically repair fixable issues.`;
+            }
+            return makeResult(output);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return makeResult(`Validation failed: ${message}`, true);
+        }
+    });
+    // ─── rebar_audit_context ─────────────────────────────────────────
+    server.registerTool("rebar_audit_context", {
+        title: "Audit Context Budget",
+        description: "[Rebar] Analyzes how much of Claude's context window your configuration artifacts consume. " +
+            "Every token spent on CLAUDE.md, skills, agents, and knowledge docs is a token NOT " +
+            "available for your actual code and conversation.\n\n" +
+            "Budget guidelines:\n" +
+            "• Skills should use < 2% of context window (~4,000 tokens)\n" +
+            "• Total config should use < 5% (~10,000 tokens)\n" +
+            "• Individual skills over 500 tokens should be trimmed\n\n" +
+            "Examples:\n" +
+            "  rebar_audit_context({ project_path: '.' })\n\n" +
+            "Returns: Token breakdown by category, budget percentage, specific warnings.\n" +
+            "Read-only: Does not modify any files.",
+        inputSchema: AuditContextInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        const { project_path } = args;
+        const absPath = resolveProjectPath(project_path);
+        try {
+            let claudemdTokens = 0;
+            let skillTokens = 0;
+            let agentTokens = 0;
+            let knowledgeTokens = 0;
+            const warnings = [];
+            const details = [];
+            // ── CLAUDE.md ───────────────────────────────────────────
+            const claudemd = await readFileSafe(sanitizePath(absPath, "CLAUDE.md"));
+            if (claudemd) {
+                claudemdTokens = estimateTokens(claudemd);
+                const lines = claudemd.split("\n").length;
+                details.push(`  CLAUDE.md: ~${claudemdTokens} tokens (${lines} lines)`);
+                if (claudemdTokens > 3000) {
+                    warnings.push(`CLAUDE.md is ${claudemdTokens} tokens — consider trimming. ` +
+                        `Focus on rules Claude needs to follow, not general documentation.`);
+                }
+            }
+            // ── Skills ──────────────────────────────────────────────
+            const skillsDir = sanitizePath(absPath, ".claude/skills");
+            const skillFiles = await listFilesRecursive(skillsDir, ".md");
+            const skillDetails = [];
+            for (const sf of skillFiles) {
+                const content = await readFileSafe(sf);
+                if (content) {
+                    const tokens = estimateTokens(content);
+                    skillTokens += tokens;
+                    const skillName = path.basename(path.dirname(sf));
+                    skillDetails.push({ name: skillName, tokens });
+                    if (tokens > 500) {
+                        warnings.push(`Skill "${skillName}" is ${tokens} tokens. ` +
+                            `Keep skills under 500 tokens for best performance.`);
+                    }
+                }
+            }
+            if (skillDetails.length > 0) {
+                details.push(`  Skills (${skillDetails.length}):`);
+                for (const s of skillDetails.sort((a, b) => b.tokens - a.tokens)) {
+                    const bar = "█".repeat(Math.min(Math.ceil(s.tokens / 100), 20));
+                    details.push(`    ${s.name}: ~${s.tokens} tokens ${bar}`);
+                }
+            }
+            // ── Agents ──────────────────────────────────────────────
+            const agentsDir = sanitizePath(absPath, ".claude/agents");
+            const agentFiles = await listFiles(agentsDir, ".md");
+            const agentDetails = [];
+            for (const af of agentFiles) {
+                const content = await readFileSafe(af);
+                if (content) {
+                    const tokens = estimateTokens(content);
+                    agentTokens += tokens;
+                    agentDetails.push({ name: path.basename(af, ".md"), tokens });
+                }
+            }
+            if (agentDetails.length > 0) {
+                details.push(`  Agents (${agentDetails.length}):`);
+                for (const a of agentDetails.sort((a, b) => b.tokens - a.tokens)) {
+                    details.push(`    ${a.name}: ~${a.tokens} tokens`);
+                }
+            }
+            // ── Knowledge ───────────────────────────────────────────
+            const docsDir = sanitizePath(absPath, ".claude/docs");
+            const docFiles = await listFilesRecursive(docsDir, ".md");
+            for (const df of docFiles) {
+                const content = await readFileSafe(df);
+                if (content) {
+                    knowledgeTokens += estimateTokens(content);
+                }
+            }
+            if (docFiles.length > 0) {
+                details.push(`  Knowledge docs (${docFiles.length}): ~${knowledgeTokens} tokens`);
+            }
+            // ── Budget calculation ──────────────────────────────────
+            const totalTokens = claudemdTokens + skillTokens + agentTokens + knowledgeTokens;
+            const budgetPercent = (totalTokens / CONTEXT_WINDOW_TOKENS) * 100;
+            const skillBudgetPercent = (skillTokens / CONTEXT_WINDOW_TOKENS) * 100;
+            if (skillBudgetPercent > SKILL_BUDGET_PERCENT) {
+                warnings.push(`Skills consume ${skillBudgetPercent.toFixed(1)}% of context ` +
+                    `(max recommended: ${SKILL_BUDGET_PERCENT}%). Trim skill content or reduce skill count.`);
+            }
+            if (budgetPercent > 5) {
+                warnings.push(`Total config uses ${budgetPercent.toFixed(1)}% of context. ` +
+                    `This reduces space for code and conversation. Target < 5%.`);
+            }
+            // ── Output ──────────────────────────────────────────────
+            const budgetBar = "█".repeat(Math.min(Math.ceil(budgetPercent), 50)) +
+                "░".repeat(Math.max(50 - Math.ceil(budgetPercent), 0));
+            let output = `Context Budget Audit\n\n` +
+                `${budgetBar} ${budgetPercent.toFixed(1)}%\n\n` +
+                `── Breakdown ──\n` +
+                details.join("\n") + "\n" +
+                `\n── Totals ──\n` +
+                `  CLAUDE.md:   ${String(claudemdTokens).padStart(6)} tokens\n` +
+                `  Skills:      ${String(skillTokens).padStart(6)} tokens\n` +
+                `  Agents:      ${String(agentTokens).padStart(6)} tokens\n` +
+                `  Knowledge:   ${String(knowledgeTokens).padStart(6)} tokens\n` +
+                `  ─────────────────────\n` +
+                `  Total:       ${String(totalTokens).padStart(6)} tokens\n` +
+                `  Budget:      ${budgetPercent.toFixed(1)}% of ${(CONTEXT_WINDOW_TOKENS / 1000).toFixed(0)}K window\n`;
+            if (warnings.length > 0) {
+                output += `\n── Recommendations ──\n`;
+                for (const w of warnings) {
+                    output += `  ⚠ ${w}\n`;
+                }
+            }
+            else {
+                output += `\n✓ Context budget is healthy — plenty of room for code and conversation.`;
+            }
+            return makeResult(output);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return makeResult(`Context audit failed: ${message}`, true);
+        }
+    });
+    // ─── rebar_doctor ───────────────────────────────────────────────
+    server.registerTool("rebar_doctor", {
+        title: "Rebar Doctor — Diagnose Setup Health",
+        description: "[Rebar] Comprehensive health check for your Rebar enforcement setup. " +
+            "Performs 10 diagnostic checks and returns PASS/WARN/FAIL status for each.\n\n" +
+            "Checks performed:\n" +
+            "1. CLAUDE.md exists with mandatory sections\n" +
+            "2. Enforcement hooks installed\n" +
+            "3. Skills installed and valid\n" +
+            "4. Agents installed\n" +
+            "5. .claudeignore exists\n" +
+            "6. Test command configured\n" +
+            "7. Strictness profile consistency\n" +
+            "8. Context budget within limits\n" +
+            "9. Cross-platform config consistency\n" +
+            "10. No configuration conflicts\n\n" +
+            "Examples:\n" +
+            "  rebar_doctor({ project_path: '.' })\n" +
+            "  rebar_doctor({ project_path: '.', output_format: 'json' })\n\n" +
+            "Returns: Health report with overall status (Healthy/Needs Attention/Broken).",
+        inputSchema: DoctorInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        const { project_path, output_format } = args;
+        const absPath = resolveProjectPath(project_path);
+        const checks = [];
+        try {
+            // ── Check 1: CLAUDE.md exists with mandatory sections ────
+            const claudemdPath = sanitizePath(absPath, "CLAUDE.md");
+            const claudemd = await readFileSafe(claudemdPath);
+            if (!claudemd) {
+                checks.push({
+                    name: "CLAUDE.md",
+                    status: "FAIL",
+                    message: "No CLAUDE.md found",
+                    details: ["Run rebar_generate_claudemd to create one"],
+                });
+            }
+            else {
+                const result = validateClaudeMD(claudemd, claudemdPath);
+                const hasBuildSection = /##\s*(Build|Test)/i.test(claudemd);
+                const hasArchSection = /##\s*(Architecture|Tech)/i.test(claudemd);
+                if (result.errors.length > 0) {
+                    checks.push({
+                        name: "CLAUDE.md",
+                        status: "FAIL",
+                        message: "CLAUDE.md has validation errors",
+                        details: result.errors,
+                    });
+                }
+                else if (!hasBuildSection || !hasArchSection) {
+                    const missing = [];
+                    if (!hasBuildSection)
+                        missing.push("Build & Test section");
+                    if (!hasArchSection)
+                        missing.push("Architecture section");
+                    checks.push({
+                        name: "CLAUDE.md",
+                        status: "WARN",
+                        message: "CLAUDE.md missing recommended sections",
+                        details: missing,
+                    });
+                }
+                else {
+                    checks.push({
+                        name: "CLAUDE.md",
+                        status: "PASS",
+                        message: "CLAUDE.md present with required sections",
+                    });
+                }
+            }
+            // ── Check 2: Enforcement hooks installed ─────────────────
+            const settingsPath = sanitizePath(absPath, ".claude/settings.json");
+            const settingsContent = await readFileSafe(settingsPath);
+            if (!settingsContent) {
+                checks.push({
+                    name: "Enforcement Hooks",
+                    status: "FAIL",
+                    message: "No .claude/settings.json found",
+                    details: ["Run rebar_init_project or rebar_set_strictness to configure hooks"],
+                });
+            }
+            else {
+                const parsed = validateJSON(settingsContent, "settings.json");
+                if (!parsed.valid) {
+                    checks.push({
+                        name: "Enforcement Hooks",
+                        status: "FAIL",
+                        message: "settings.json is invalid JSON",
+                        details: parsed.errors,
+                    });
+                }
+                else {
+                    const settings = parsed.parsed;
+                    const hooks = settings.hooks;
+                    if (!hooks || Object.keys(hooks).length === 0) {
+                        checks.push({
+                            name: "Enforcement Hooks",
+                            status: "WARN",
+                            message: "No hooks configured",
+                            details: ["Run rebar_set_strictness to add enforcement hooks"],
+                        });
+                    }
+                    else {
+                        const hookCount = Object.values(hooks).reduce((sum, arr) => sum + arr.length, 0);
+                        const hasPreToolCall = Array.isArray(hooks.PreToolCall) && hooks.PreToolCall.length > 0;
+                        const hasPostToolCall = Array.isArray(hooks.PostToolCall) && hooks.PostToolCall.length > 0;
+                        if (!hasPreToolCall && !hasPostToolCall) {
+                            checks.push({
+                                name: "Enforcement Hooks",
+                                status: "WARN",
+                                message: `${hookCount} hook(s) found but no tool-level enforcement`,
+                                details: ["Consider adding PreToolCall/PostToolCall hooks"],
+                            });
+                        }
+                        else {
+                            checks.push({
+                                name: "Enforcement Hooks",
+                                status: "PASS",
+                                message: `${hookCount} enforcement hook(s) installed`,
+                            });
+                        }
+                    }
+                }
+            }
+            // ── Check 3: Skills installed ────────────────────────────
+            const skillsDir = sanitizePath(absPath, ".claude/skills");
+            const skillFiles = await listFilesRecursive(skillsDir, ".md");
+            if (skillFiles.length === 0) {
+                checks.push({
+                    name: "Skills",
+                    status: "WARN",
+                    message: "No skills installed",
+                    details: ["Skills provide reusable prompts. Run rebar_create_skill to add one."],
+                });
+            }
+            else {
+                const invalidSkills = [];
+                for (const sf of skillFiles) {
+                    const content = await readFileSafe(sf);
+                    if (content) {
+                        const validation = validateSkillFrontmatter(content);
+                        if (!validation.valid) {
+                            invalidSkills.push(path.basename(path.dirname(sf)));
+                        }
+                    }
+                }
+                if (invalidSkills.length > 0) {
+                    checks.push({
+                        name: "Skills",
+                        status: "WARN",
+                        message: `${skillFiles.length} skill(s) found, ${invalidSkills.length} with invalid frontmatter`,
+                        details: invalidSkills.map(s => `Invalid: ${s}`),
+                    });
+                }
+                else {
+                    checks.push({
+                        name: "Skills",
+                        status: "PASS",
+                        message: `${skillFiles.length} skill(s) installed and valid`,
+                    });
+                }
+            }
+            // ── Check 4: Agents installed ────────────────────────────
+            const agentsDir = sanitizePath(absPath, ".claude/agents");
+            const agentFiles = await listFiles(agentsDir, ".md");
+            if (agentFiles.length === 0) {
+                checks.push({
+                    name: "Agents",
+                    status: "WARN",
+                    message: "No custom agents installed",
+                    details: ["Custom agents extend Claude's capabilities. Optional but recommended."],
+                });
+            }
+            else {
+                checks.push({
+                    name: "Agents",
+                    status: "PASS",
+                    message: `${agentFiles.length} agent(s) installed`,
+                });
+            }
+            // ── Check 5: .claudeignore exists ────────────────────────
+            const claudeignorePath = sanitizePath(absPath, ".claudeignore");
+            if (await fileExists(claudeignorePath)) {
+                checks.push({
+                    name: ".claudeignore",
+                    status: "PASS",
+                    message: ".claudeignore present",
+                });
+            }
+            else {
+                checks.push({
+                    name: ".claudeignore",
+                    status: "WARN",
+                    message: "No .claudeignore file",
+                    details: ["Add .claudeignore to exclude large or sensitive files from context"],
+                });
+            }
+            // ── Check 6: Test command configured ─────────────────────
+            let testCommandFound = false;
+            if (claudemd) {
+                // Look for test command in CLAUDE.md
+                testCommandFound = /npm (run )?test|yarn test|pnpm test|pytest|cargo test|go test|mvn test|gradle test/i.test(claudemd);
+            }
+            // Also check package.json for test script
+            const packageJsonPath = sanitizePath(absPath, "package.json");
+            const packageJson = await readFileSafe(packageJsonPath);
+            if (packageJson) {
+                try {
+                    const pkg = JSON.parse(packageJson);
+                    if (pkg.scripts?.test && !pkg.scripts.test.includes("no test specified")) {
+                        testCommandFound = true;
+                    }
+                }
+                catch {
+                    // Invalid JSON, ignore
+                }
+            }
+            if (testCommandFound) {
+                checks.push({
+                    name: "Test Command",
+                    status: "PASS",
+                    message: "Test command detected",
+                });
+            }
+            else {
+                checks.push({
+                    name: "Test Command",
+                    status: "WARN",
+                    message: "No test command found",
+                    details: ["Add test instructions to CLAUDE.md or configure npm test"],
+                });
+            }
+            // ── Check 7: Strictness profile consistency ──────────────
+            if (settingsContent) {
+                const parsed = validateJSON(settingsContent, "settings.json");
+                if (parsed.valid && parsed.parsed) {
+                    const settings = parsed.parsed;
+                    const hooks = settings.hooks;
+                    if (hooks) {
+                        const profile = detectCurrentProfile(hooks);
+                        if (profile) {
+                            checks.push({
+                                name: "Strictness Profile",
+                                status: "PASS",
+                                message: `Detected profile: ${profile}`,
+                            });
+                        }
+                        else {
+                            checks.push({
+                                name: "Strictness Profile",
+                                status: "WARN",
+                                message: "Custom or mixed hook configuration",
+                                details: ["Hooks don't match a standard strictness profile"],
+                            });
+                        }
+                    }
+                    else {
+                        checks.push({
+                            name: "Strictness Profile",
+                            status: "WARN",
+                            message: "No strictness profile configured",
+                            details: ["Run rebar_set_strictness to set a profile"],
+                        });
+                    }
+                }
+            }
+            else {
+                checks.push({
+                    name: "Strictness Profile",
+                    status: "FAIL",
+                    message: "Cannot determine profile - settings.json missing",
+                });
+            }
+            // ── Check 8: 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);
+            }
+            for (const af of agentFiles) {
+                const content = await readFileSafe(af);
+                if (content)
+                    totalTokens += estimateTokens(content);
+            }
+            const budgetPercent = (totalTokens / CONTEXT_WINDOW_TOKENS) * 100;
+            if (budgetPercent > 10) {
+                checks.push({
+                    name: "Context Budget",
+                    status: "FAIL",
+                    message: `Config uses ${budgetPercent.toFixed(1)}% of context (>10%)`,
+                    details: ["Reduce CLAUDE.md size or trim skills"],
+                });
+            }
+            else if (budgetPercent > 5) {
+                checks.push({
+                    name: "Context Budget",
+                    status: "WARN",
+                    message: `Config uses ${budgetPercent.toFixed(1)}% of context`,
+                    details: ["Consider trimming for better performance"],
+                });
+            }
+            else {
+                checks.push({
+                    name: "Context Budget",
+                    status: "PASS",
+                    message: `Config uses ${budgetPercent.toFixed(1)}% of context`,
+                });
+            }
+            // ── Check 9: Cross-platform config consistency ───────────
+            const cursorRulesDir = sanitizePath(absPath, ".cursor/rules");
+            const windsurfRulesDir = sanitizePath(absPath, ".windsurf/rules");
+            const agentsMdPath = sanitizePath(absPath, "AGENTS.md");
+            const hasCursor = await fileExists(cursorRulesDir);
+            const hasWindsurf = await fileExists(windsurfRulesDir);
+            const hasCodex = await fileExists(agentsMdPath);
+            const hasClaude = !!claudemd;
+            const platforms = [];
+            if (hasClaude)
+                platforms.push("Claude Code");
+            if (hasCursor)
+                platforms.push("Cursor");
+            if (hasWindsurf)
+                platforms.push("Windsurf");
+            if (hasCodex)
+                platforms.push("Codex");
+            if (platforms.length === 0) {
+                checks.push({
+                    name: "Platform Config",
+                    status: "FAIL",
+                    message: "No AI platform configuration found",
+                });
+            }
+            else if (platforms.length === 1) {
+                checks.push({
+                    name: "Platform Config",
+                    status: "PASS",
+                    message: `Configured for: ${platforms[0]}`,
+                });
+            }
+            else {
+                checks.push({
+                    name: "Platform Config",
+                    status: "PASS",
+                    message: `Multi-platform: ${platforms.join(", ")}`,
+                });
+            }
+            // ── Check 10: No configuration conflicts ─────────────────
+            const conflicts = [];
+            // Check for conflicting hook behaviors
+            if (settingsContent) {
+                const parsed = validateJSON(settingsContent, "settings.json");
+                if (parsed.valid && parsed.parsed) {
+                    const settings = parsed.parsed;
+                    const hooks = settings.hooks;
+                    if (hooks?.PreToolCall && Array.isArray(hooks.PreToolCall)) {
+                        const blockingHooks = hooks.PreToolCall.filter((h) => {
+                            const hook = h;
+                            return hook.type === "block" || hook.exitBehavior === "block";
+                        });
+                        if (blockingHooks.length > 3) {
+                            conflicts.push("Many blocking hooks may slow down Claude significantly");
+                        }
+                    }
+                }
+            }
+            // Check for duplicate skills
+            const skillNames = new Set();
+            for (const sf of skillFiles) {
+                const name = path.basename(path.dirname(sf));
+                if (skillNames.has(name)) {
+                    conflicts.push(`Duplicate skill name: ${name}`);
+                }
+                skillNames.add(name);
+            }
+            if (conflicts.length > 0) {
+                checks.push({
+                    name: "Config Conflicts",
+                    status: "WARN",
+                    message: `${conflicts.length} potential conflict(s)`,
+                    details: conflicts,
+                });
+            }
+            else {
+                checks.push({
+                    name: "Config Conflicts",
+                    status: "PASS",
+                    message: "No configuration conflicts detected",
+                });
+            }
+            // ── Calculate overall health ─────────────────────────────
+            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;
+            let overallStatus;
+            let overallEmoji;
+            if (failCount === 0 && warnCount === 0) {
+                overallStatus = "Healthy";
+                overallEmoji = "✓";
+            }
+            else if (failCount === 0) {
+                overallStatus = "Needs Attention";
+                overallEmoji = "⚠";
+            }
+            else {
+                overallStatus = "Broken";
+                overallEmoji = "✗";
+            }
+            // ── Format output ────────────────────────────────────────
+            if (output_format === "json") {
+                return makeResult(JSON.stringify({
+                    overall: overallStatus,
+                    summary: { pass: passCount, warn: warnCount, fail: failCount },
+                    checks: checks.map(c => ({
+                        name: c.name,
+                        status: c.status,
+                        message: c.message,
+                        details: c.details,
+                    })),
+                }, null, 2));
+            }
+            // Markdown format
+            let output = `# Rebar Doctor Report\n\n`;
+            output += `**Overall: ${overallEmoji} ${overallStatus}**\n`;
+            output += `${passCount} passed, ${warnCount} warnings, ${failCount} failed\n\n`;
+            output += `## Health Checks\n\n`;
+            for (const check of checks) {
+                const icon = check.status === "PASS" ? "✓" : check.status === "WARN" ? "⚠" : "✗";
+                output += `### ${icon} ${check.name}: ${check.status}\n`;
+                output += `${check.message}\n`;
+                if (check.details && check.details.length > 0) {
+                    for (const d of check.details) {
+                        output += `  - ${d}\n`;
+                    }
+                }
+                output += "\n";
+            }
+            if (failCount > 0) {
+                output += `## Next Steps\n\n`;
+                output += `Fix the failing checks above to get your project into a healthy state.\n`;
+                output += `Run \`rebar_init_project\` for a guided setup, or fix issues individually.\n`;
+            }
+            else if (warnCount > 0) {
+                output += `## Recommendations\n\n`;
+                output += `Your setup is functional but could be improved. Review the warnings above.\n`;
+            }
+            return makeResult(output.trimEnd());
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return makeResult(`Doctor check failed: ${message}`, true);
+        }
+    });
+    // ─── rebar_metrics ──────────────────────────────────────────────
+    server.registerTool("rebar_metrics", {
+        title: "Rebar Metrics — Quality Score Dashboard",
+        description: "[Rebar] View or record quality score metrics over time. Tracks trends and " +
+            "helps identify when code quality is improving or declining.\n\n" +
+            "Actions:\n" +
+            "• view: Display historical quality scores and trends\n" +
+            "• record: Calculate and store current quality score\n\n" +
+            "Metrics stored in .rebar/metrics.json include:\n" +
+            "• Overall score (0-100)\n" +
+            "• Category breakdown (CLAUDE.md, hooks, skills, context, practices)\n" +
+            "• Timestamp for trend analysis\n\n" +
+            "Examples:\n" +
+            "  rebar_metrics({ project_path: '.', action: 'view' })\n" +
+            "  rebar_metrics({ project_path: '.', action: 'record' })\n\n" +
+            "Returns: Quality score history with trend indicators.",
+        inputSchema: MetricsInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        const { project_path, action, output_format } = args;
+        const absPath = resolveProjectPath(project_path);
+        const metricsPath = sanitizePath(absPath, ".rebar/metrics.json");
+        try {
+            // Load existing metrics
+            let metrics = [];
+            const existing = await readFileSafe(metricsPath);
+            if (existing) {
+                try {
+                    metrics = JSON.parse(existing);
+                }
+                catch {
+                    metrics = [];
+                }
+            }
+            if (action === "record") {
+                // Calculate current score
+                const claudemd = await readFileSafe(sanitizePath(absPath, "CLAUDE.md"));
+                const settings = await readFileSafe(sanitizePath(absPath, ".claude/settings.json"));
+                const skillsDir = sanitizePath(absPath, ".claude/skills");
+                const skillFiles = await listFilesRecursive(skillsDir, ".md");
+                // CLAUDE.md score (0-25)
+                let claudemdScore = 0;
+                if (claudemd) {
+                    claudemdScore += 10;
+                    const result = validateClaudeMD(claudemd, "CLAUDE.md");
+                    if (result.valid)
+                        claudemdScore += 5;
+                    if (/##\s*(Build|Test)/i.test(claudemd))
+                        claudemdScore += 5;
+                    if (/##\s*(Architecture)/i.test(claudemd))
+                        claudemdScore += 5;
+                }
+                // Enforcement score (0-25)
+                let enforcementScore = 0;
+                if (settings) {
+                    const parsed = validateJSON(settings, "settings.json");
+                    if (parsed.valid && parsed.parsed) {
+                        const s = parsed.parsed;
+                        const hooks = s.hooks;
+                        if (hooks && Object.keys(hooks).length > 0) {
+                            enforcementScore += 10;
+                            const profile = detectCurrentProfile(hooks);
+                            if (profile === "standard")
+                                enforcementScore += 5;
+                            if (profile === "strict")
+                                enforcementScore += 10;
+                            if (profile === "paranoid")
+                                enforcementScore += 15;
+                        }
+                    }
+                }
+                // Skills score (0-20)
+                let skillsScore = 0;
+                if (skillFiles.length > 0) {
+                    skillsScore += 10;
+                    let validSkills = 0;
+                    for (const sf of skillFiles) {
+                        const content = await readFileSafe(sf);
+                        if (content && validateSkillFrontmatter(content).valid) {
+                            validSkills++;
+                        }
+                    }
+                    if (validSkills === skillFiles.length)
+                        skillsScore += 10;
+                }
+                else {
+                    skillsScore = 10; // Optional, no penalty
+                }
+                // Context score (0-15)
+                let contextScore = 0;
+                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)
+                    contextScore = 15;
+                else if (budgetPercent <= 5)
+                    contextScore = 10;
+                else if (budgetPercent <= 10)
+                    contextScore = 5;
+                // Practices score (0-15)
+                let practicesScore = 0;
+                if (await fileExists(sanitizePath(absPath, ".claudeignore")))
+                    practicesScore += 5;
+                const agentsDir = sanitizePath(absPath, ".claude/agents");
+                const agentFiles = await listFiles(agentsDir, ".md");
+                if (agentFiles.length > 0)
+                    practicesScore += 5;
+                if (await fileExists(sanitizePath(absPath, ".claude/docs")))
+                    practicesScore += 5;
+                const totalScore = claudemdScore + enforcementScore + skillsScore + contextScore + practicesScore;
+                // Add new entry
+                const entry = {
+                    timestamp: new Date().toISOString(),
+                    score: totalScore,
+                    categories: {
+                        claudemd: claudemdScore,
+                        enforcement: enforcementScore,
+                        skills: skillsScore,
+                        context: contextScore,
+                        practices: practicesScore,
+                    },
+                };
+                metrics.push(entry);
+                // Keep only last 100 entries
+                if (metrics.length > 100) {
+                    metrics = metrics.slice(-100);
+                }
+                // Ensure directory exists and save
+                await atomicWrite(metricsPath, JSON.stringify(metrics, null, 2));
+                // Calculate trend
+                let trend = "→";
+                if (metrics.length >= 2) {
+                    const prev = metrics[metrics.length - 2].score;
+                    if (totalScore > prev)
+                        trend = "↑";
+                    else if (totalScore < prev)
+                        trend = "↓";
+                }
+                if (output_format === "json") {
+                    return makeResult(JSON.stringify({
+                        action: "recorded",
+                        score: totalScore,
+                        trend,
+                        categories: entry.categories,
+                        historyCount: metrics.length,
+                    }, null, 2));
+                }
+                return makeResult(`✓ Quality score recorded: ${totalScore}/100 ${trend}\n\n` +
+                    `Categories:\n` +
+                    `  CLAUDE.md:   ${claudemdScore}/25\n` +
+                    `  Enforcement: ${enforcementScore}/25\n` +
+                    `  Skills:      ${skillsScore}/20\n` +
+                    `  Context:     ${contextScore}/15\n` +
+                    `  Practices:   ${practicesScore}/15\n\n` +
+                    `History: ${metrics.length} entries stored`);
+            }
+            // action === "view"
+            if (metrics.length === 0) {
+                return makeResult("No metrics history found.\n\n" +
+                    "Run `rebar_metrics` with `action: 'record'` to capture the current score.\n" +
+                    "Or use `rebar audit` from the CLI to generate and store metrics.");
+            }
+            // Calculate trend
+            const latest = metrics[metrics.length - 1];
+            let trend = "stable";
+            let trendEmoji = "→";
+            if (metrics.length >= 3) {
+                const recent = metrics.slice(-3).map(m => m.score);
+                const avg = recent.reduce((a, b) => a + b, 0) / recent.length;
+                if (latest.score > avg + 2) {
+                    trend = "improving";
+                    trendEmoji = "↑";
+                }
+                else if (latest.score < avg - 2) {
+                    trend = "declining";
+                    trendEmoji = "↓";
+                }
+            }
+            if (output_format === "json") {
+                return makeResult(JSON.stringify({
+                    latest: latest.score,
+                    trend,
+                    historyCount: metrics.length,
+                    history: metrics.slice(-10),
+                }, null, 2));
+            }
+            // Markdown format
+            let output = `# Rebar Quality Metrics\n\n`;
+            output += `**Current Score: ${latest.score}/100 ${trendEmoji} (${trend})**\n\n`;
+            output += `## History (last 10)\n\n`;
+            output += `| Date | Score | Trend |\n`;
+            output += `|------|-------|-------|\n`;
+            const recentMetrics = metrics.slice(-10);
+            for (let i = 0; i < recentMetrics.length; i++) {
+                const m = recentMetrics[i];
+                const date = new Date(m.timestamp).toLocaleDateString();
+                let itemTrend = "→";
+                if (i > 0) {
+                    const prev = recentMetrics[i - 1].score;
+                    if (m.score > prev)
+                        itemTrend = "↑";
+                    else if (m.score < prev)
+                        itemTrend = "↓";
+                }
+                output += `| ${date} | ${m.score}/100 | ${itemTrend} |\n`;
+            }
+            output += `\n## Latest Category Breakdown\n\n`;
+            const cat = latest.categories;
+            output += `- CLAUDE.md:   ${cat.claudemd}/25\n`;
+            output += `- Enforcement: ${cat.enforcement}/25\n`;
+            output += `- Skills:      ${cat.skills}/20\n`;
+            output += `- Context:     ${cat.context}/15\n`;
+            output += `- Practices:   ${cat.practices}/15\n`;
+            return makeResult(output.trimEnd());
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return makeResult(`Metrics operation failed: ${message}`, true);
+        }
+    });
+    // ─── rebar_badge ────────────────────────────────────────────────
+    server.registerTool("rebar_badge", {
+        title: "Rebar Badge — Generate Quality Score Badge",
+        description: "[Rebar] Generates an SVG badge showing the project's quality score. " +
+            "Perfect for README files to showcase code quality.\n\n" +
+            "Badge colors:\n" +
+            "• Green (80-100): Excellent quality\n" +
+            "• Yellow-green (60-79): Good quality\n" +
+            "• Yellow (40-59): Fair quality\n" +
+            "• Red (0-39): Needs work\n\n" +
+            "The badge is saved to .rebar/badge.svg and can be embedded in README.md.\n\n" +
+            "Examples:\n" +
+            "  rebar_badge({ project_path: '.' })\n" +
+            "  rebar_badge({ project_path: '.', style: 'flat-square' })\n\n" +
+            "Returns: SVG badge content and embedding instructions.",
+        inputSchema: BadgeInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        const { project_path, style, output_format } = args;
+        const absPath = resolveProjectPath(project_path);
+        try {
+            // Calculate current score (quick version)
+            let score = 0;
+            const claudemd = await readFileSafe(sanitizePath(absPath, "CLAUDE.md"));
+            const settings = await readFileSafe(sanitizePath(absPath, ".claude/settings.json"));
+            // CLAUDE.md (25 points)
+            if (claudemd) {
+                score += 10;
+                const result = validateClaudeMD(claudemd, "CLAUDE.md");
+                if (result.valid)
+                    score += 5;
+                if (/##\s*(Build|Test)/i.test(claudemd))
+                    score += 5;
+                if (/##\s*(Architecture)/i.test(claudemd))
+                    score += 5;
+            }
+            // Enforcement (25 points)
+            if (settings) {
+                const parsed = validateJSON(settings, "settings.json");
+                if (parsed.valid && parsed.parsed) {
+                    const s = parsed.parsed;
+                    const hooks = s.hooks;
+                    if (hooks && Object.keys(hooks).length > 0) {
+                        score += 10;
+                        const profile = detectCurrentProfile(hooks);
+                        if (profile === "standard")
+                            score += 5;
+                        if (profile === "strict")
+                            score += 10;
+                        if (profile === "paranoid")
+                            score += 15;
+                    }
+                }
+            }
+            // Skills (20 points - simplified)
+            const skillsDir = sanitizePath(absPath, ".claude/skills");
+            const skillFiles = await listFilesRecursive(skillsDir, ".md");
+            if (skillFiles.length > 0)
+                score += 15;
+            else
+                score += 10; // Optional
+            // Context budget (15 points - simplified)
+            let totalTokens = 0;
+            if (claudemd)
+                totalTokens += estimateTokens(claudemd);
+            const budgetPercent = (totalTokens / CONTEXT_WINDOW_TOKENS) * 100;
+            if (budgetPercent <= 5)
+                score += 15;
+            else if (budgetPercent <= 10)
+                score += 10;
+            else
+                score += 5;
+            // Best practices (15 points)
+            if (await fileExists(sanitizePath(absPath, ".claudeignore")))
+                score += 5;
+            if (await fileExists(sanitizePath(absPath, ".claude/agents")))
+                score += 5;
+            if (await fileExists(sanitizePath(absPath, ".claude/docs")))
+                score += 5;
+            // Determine color and label
+            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";
+            }
+            // Generate SVG based on style
+            let svg;
+            const radius = style === "flat-square" ? "0" : style === "plastic" ? "4" : "3";
+            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="${radius}" 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 (output_format === "json") {
+                return makeResult(JSON.stringify({
+                    score,
+                    label,
+                    color,
+                    style,
+                    svg,
+                    embedMarkdown: "![Rebar Score](.rebar/badge.svg)",
+                    embedHtml: `<img src=".rebar/badge.svg" alt="Rebar Score: ${score}/100">`,
+                }, null, 2));
+            }
+            // Save badge to file
+            const badgePath = sanitizePath(absPath, ".rebar/badge.svg");
+            await atomicWrite(badgePath, svg);
+            return makeResult(`✓ Badge generated: .rebar/badge.svg\n\n` +
+                `Score: ${score}/100 (${label})\n\n` +
+                `## Embed in README.md\n\n` +
+                "```markdown\n" +
+                "![Rebar Score](.rebar/badge.svg)\n" +
+                "```\n\n" +
+                "## Or use HTML\n\n" +
+                "```html\n" +
+                `<img src=".rebar/badge.svg" alt="Rebar Score: ${score}/100">\n` +
+                "```");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return makeResult(`Badge generation failed: ${message}`, true);
+        }
+    });
+    // ─── rebar_custom_rules ─────────────────────────────────────────
+    server.registerTool("rebar_custom_rules", {
+        title: "Rebar Custom Rules — Manage Quality Rules",
+        description: "[Rebar] Manage custom quality rules defined in .rebar/rules.yaml. " +
+            "Custom rules extend the built-in checks with project-specific requirements.\n\n" +
+            "Actions:\n" +
+            "• list: Show configured custom rules\n" +
+            "• init: Create a default rules.yaml template\n" +
+            "• evaluate: Run all custom rules and report results\n\n" +
+            "Rule types supported:\n" +
+            "• file-exists: Check if a file exists\n" +
+            "• file-contains: Check if file contains a pattern\n" +
+            "• file-not-contains: Check file doesn't contain a pattern\n" +
+            "• glob-count: Count files matching a pattern (min/max)\n\n" +
+            "Examples:\n" +
+            "  rebar_custom_rules({ project_path: '.', action: 'init' })\n" +
+            "  rebar_custom_rules({ project_path: '.', action: 'evaluate' })\n\n" +
+            "Returns: Rule list, template, or evaluation results.",
+        inputSchema: CustomRulesInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        const { project_path, action, output_format } = args;
+        const absPath = resolveProjectPath(project_path);
+        try {
+            if (action === "init") {
+                // Create default rules template
+                const rulesPath = sanitizePath(absPath, ".rebar/rules.yaml");
+                const template = generateDefaultRulesTemplate();
+                await atomicWrite(rulesPath, template);
+                return makeResult(`✓ Created .rebar/rules.yaml\n\n` +
+                    `Default rules included:\n` +
+                    `• readme-exists: Check README.md exists\n` +
+                    `• license-exists: Check LICENSE exists\n` +
+                    `• no-hardcoded-localhost: Prevent localhost URLs\n` +
+                    `• test-files-exist: Ensure tests exist\n\n` +
+                    `Edit .rebar/rules.yaml to customize rules for your project.\n` +
+                    `Run with action: 'evaluate' to check rules.`);
+            }
+            // Load existing rules
+            const config = await loadCustomRules(absPath);
+            if (action === "list") {
+                if (!config || !config.rules || config.rules.length === 0) {
+                    return makeResult("No custom rules configured.\n\n" +
+                        "Run with `action: 'init'` to create a default rules.yaml template.\n" +
+                        "Or create .rebar/rules.yaml manually.");
+                }
+                if (output_format === "json") {
+                    return makeResult(JSON.stringify(config, null, 2));
+                }
+                let output = `# Custom Rules\n\n`;
+                output += `Found ${config.rules.length} rule(s) in .rebar/rules.yaml\n\n`;
+                for (const rule of config.rules) {
+                    const status = rule.enabled === false ? " (disabled)" : "";
+                    const icon = rule.severity === "error" ? "❌" : rule.severity === "warning" ? "⚠️" : "ℹ️";
+                    output += `## ${icon} ${rule.name}${status}\n`;
+                    output += `ID: \`${rule.id}\`\n`;
+                    output += `Type: ${rule.type}\n`;
+                    if (rule.description)
+                        output += `${rule.description}\n`;
+                    if (rule.target)
+                        output += `Target: \`${rule.target}\`\n`;
+                    if (rule.pattern)
+                        output += `Pattern: \`${rule.pattern}\`\n`;
+                    output += "\n";
+                }
+                return makeResult(output.trimEnd());
+            }
+            // action === "evaluate"
+            if (!config || !config.rules || config.rules.length === 0) {
+                return makeResult("No custom rules to evaluate.\n\n" +
+                    "Run with `action: 'init'` to create a default rules.yaml template.");
+            }
+            const results = await evaluateAllRules(absPath);
+            const passed = results.filter(r => r.passed).length;
+            const failed = results.filter(r => !r.passed).length;
+            const errors = results.filter(r => !r.passed && r.severity === "error").length;
+            const warnings = results.filter(r => !r.passed && r.severity === "warning").length;
+            if (output_format === "json") {
+                return makeResult(JSON.stringify({
+                    total: results.length,
+                    passed,
+                    failed,
+                    errors,
+                    warnings,
+                    results,
+                }, null, 2));
+            }
+            let output = `# Custom Rules Evaluation\n\n`;
+            output += `**Results: ${passed}/${results.length} passed**\n`;
+            if (errors > 0)
+                output += `❌ ${errors} error(s)\n`;
+            if (warnings > 0)
+                output += `⚠️ ${warnings} warning(s)\n`;
+            output += "\n";
+            for (const result of results) {
+                const icon = result.passed ? "✓" : result.severity === "error" ? "✗" : "⚠";
+                output += `${icon} **${result.name}**\n`;
+                output += `  ${result.message}\n\n`;
+            }
+            if (errors > 0) {
+                output += `---\n`;
+                output += `⚠️ ${errors} error-level rule(s) failed. Fix these to improve quality.`;
+            }
+            return makeResult(output.trimEnd());
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return makeResult(`Custom rules operation failed: ${message}`, true);
+        }
+    });
+}
+//# sourceMappingURL=management.js.map