rebar-mcp 2.0.0

package/src/tools/scaffolding.ts

@@ -0,0 +1,909 @@
+/**
+ * Tier 1: Core Scaffolding Tools
+ * rebar_init_project, rebar_generate_claudemd, rebar_create_skill,
+ * rebar_create_agent, rebar_create_hook, rebar_create_command
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as path from "node:path";
+import {
+  InitProjectInputSchema,
+  GenerateClaudeMDInputSchema,
+  CreateSkillInputSchema,
+  CreateAgentInputSchema,
+  CreateHookInputSchema,
+  CreateCommandInputSchema,
+  SetStrictnessInputSchema,
+} from "../schemas/scaffolding.js";
+import {
+  getHooksForProfile,
+  hooksToSettingsFormat,
+  detectCurrentProfile,
+  type StrictnessProfile,
+} from "../services/strictness.js";
+import {
+  resolveProjectPath,
+  sanitizePath,
+  atomicWrite,
+  ensureDir,
+  fileExists,
+  readFileSafe,
+  safeWriteFile,
+} from "../services/file-ops.js";
+import { analyzeProject, summarizeAnalysis } from "../services/project-analyzer.js";
+import { generateClaudeMD } from "../services/claudemd-generator.js";
+import { resolvePlatforms, type AIPlatform } from "../services/platform-detect.js";
+import { generateCursorConfig, getDefaultCursorSkills } from "../services/cursor-generator.js";
+import { generateWindsurfConfig, getDefaultWindsurfRules } from "../services/windsurf-generator.js";
+import { generateCodexConfig } from "../services/codex-generator.js";
+import type { GeneratedFile, ToolResult } from "../types.js";
+
+/**
+ * Loads a template from the templates directory.
+ */
+async function loadTemplate(category: string, name: string): Promise<string> {
+  const locations = [
+    path.join(import.meta.dirname, "../../templates", category, `${name}.md`),
+    path.join(process.cwd(), "templates", category, `${name}.md`),
+  ];
+  for (const loc of locations) {
+    const content = await readFileSafe(loc);
+    if (content !== null) return content;
+  }
+  throw new Error(`Template not found: ${category}/${name}.md`);
+}
+
+function makeResult(text: string, isError = false): ToolResult {
+  return {
+    content: [{ type: "text", text }],
+    ...(isError ? { isError: true } : {}),
+  };
+}
+
+/**
+ * Generates smart permissions based on what the project actually uses.
+ */
+function generatePermissions(analysis: ReturnType<typeof Object>): { allow: string[]; deny: string[] } {
+  const allow: string[] = [];
+  const deny: string[] = [
+    "Bash(rm -rf *)",
+    "Read(./.env)",
+    "Read(./.env.*)",
+  ];
+
+  // Always allow git
+  allow.push("Bash(git status)", "Bash(git diff *)", "Bash(git log *)", "Bash(git add *)", "Bash(git commit *)");
+
+  const a = analysis as Awaited<ReturnType<typeof analyzeProject>>;
+
+  // Build commands from actual package.json
+  for (const key of Object.keys(a.buildCommands)) {
+    const pm = a.packageManager === "yarn" ? "yarn" : a.packageManager === "pnpm" ? "pnpm" : a.packageManager === "bun" ? "bun run" : "npm run";
+    allow.push(`Bash(${pm} ${key})`);
+  }
+  for (const key of Object.keys(a.testCommands)) {
+    const pm = a.packageManager === "yarn" ? "yarn" : a.packageManager === "pnpm" ? "pnpm" : a.packageManager === "bun" ? "bun run" : "npm run";
+    allow.push(`Bash(${pm} ${key} *)`);
+  }
+
+  // Language-specific
+  if (a.usesTypeScript) {
+    allow.push("Bash(npx tsc --noEmit)");
+  }
+  if (a.language === "python") {
+    allow.push("Bash(pytest *)", "Bash(ruff check *)", "Bash(mypy *)");
+  }
+  if (a.language === "go") {
+    allow.push("Bash(go build *)", "Bash(go test *)", "Bash(golangci-lint run *)");
+  }
+  if (a.language === "rust") {
+    allow.push("Bash(cargo build *)", "Bash(cargo test *)", "Bash(cargo clippy *)");
+  }
+  if (a.language === "java") {
+    allow.push("Bash(./mvnw *)", "Bash(./gradlew *)");
+  }
+
+  // ORM-specific
+  if (a.database === "Prisma") {
+    allow.push("Bash(npx prisma generate)", "Bash(npx prisma db push)");
+  }
+
+  return { allow, deny };
+}
+
+export function registerScaffoldingTools(server: McpServer): void {
+  // ─── rebar_init_project ──────────────────────────────────────────
+  server.registerTool(
+    "rebar_init_project",
+    {
+      title: "Initialize Project",
+      description:
+        "[Rebar] Full project bootstrap with enforcement hooks, opinionated templates, and quality guardrails. " +
+        "Reads package.json, Cargo.toml, go.mod, pom.xml, and other project manifests to generate perfectly tailored CLAUDE.md, " +
+        ".claude/ directory, settings.json with smart permissions, agents, .mcp.json, and .claudeignore.\n\n" +
+        "The generated CLAUDE.md includes real build commands, actual dependencies, " +
+        "framework-specific architecture rules, and detected patterns — not generic templates.\n\n" +
+        "Examples:\n" +
+        "  rebar_init_project({ project_path: '.', tech_stack: ['nextjs'], team_size: 5 })\n" +
+        "  rebar_init_project({ project_path: './api', tech_stack: ['fastapi'], team_size: 12, compliance: ['hipaa'] })\n" +
+        "  rebar_init_project({ project_path: '.', tech_stack: ['springboot'], team_size: 50, compliance: ['sox', 'soc2'] })\n\n" +
+        "Returns: List of all generated files with descriptions.\n" +
+        "Error handling: Returns actionable suggestions if project_path doesn't exist or isn't writable.",
+      inputSchema: InitProjectInputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const { project_path, tech_stack, team_size, compliance, strictness, platforms } = args;
+      const absPath = resolveProjectPath(project_path);
+      const generatedFiles: GeneratedFile[] = [];
+      const effectiveStrictness = (strictness || "standard") as StrictnessProfile;
+
+      // Resolve which platforms to generate for
+      const platformsArray = (platforms || ["all"]) as string[];
+      const targetPlatforms = await resolvePlatforms(absPath, platformsArray);
+
+      try {
+        // 1. Deep project analysis — this is what makes the output smart
+        const analysis = await analyzeProject(absPath);
+
+        // Merge user-specified tech stack with auto-detected
+        const userStacks = tech_stack as string[];
+        for (const stack of userStacks) {
+          if (!analysis.stacks.includes(stack as typeof analysis.stacks[number])) {
+            analysis.stacks.push(stack as typeof analysis.stacks[number]);
+          }
+        }
+
+        // 2. Create directory structure
+        const dirs = [
+          ".claude/agents",
+          ".claude/skills",
+          ".claude/docs",
+          ".claude/scripts",
+        ];
+        for (const dir of dirs) {
+          await ensureDir(sanitizePath(absPath, dir));
+        }
+
+        // 3. Generate CLAUDE.md from real analysis
+        const claudemd = generateClaudeMD(analysis, compliance);
+        const claudemdPath = sanitizePath(absPath, "CLAUDE.md");
+        await safeWriteFile(claudemdPath, claudemd, false);
+        generatedFiles.push({
+          path: "CLAUDE.md",
+          content: claudemd,
+          description: `Project CLAUDE.md (${claudemd.split("\n").length} lines, tailored to ${analysis.stacks.join("+")})`
+        });
+
+        // 4. Generate .claudeignore based on actual project
+        const ignoreEntries = ["node_modules/", "dist/", ".git/", "coverage/"];
+        if (analysis.language === "python") ignoreEntries.push("__pycache__/", ".venv/", "*.pyc");
+        if (analysis.language === "rust") ignoreEntries.push("target/");
+        if (analysis.language === "go") ignoreEntries.push("vendor/");
+        if (analysis.language === "java") ignoreEntries.push("target/", "build/", ".gradle/");
+        if (analysis.hasDocker) ignoreEntries.push(".docker/");
+        const claudeignore = ignoreEntries.join("\n") + "\n";
+        const ignorePath = sanitizePath(absPath, ".claudeignore");
+        await safeWriteFile(ignorePath, claudeignore, false);
+        generatedFiles.push({ path: ".claudeignore", content: claudeignore, description: `Ignore file (${ignoreEntries.length} patterns)` });
+
+        // 5. Generate smart settings.json with real permissions and enforcement hooks
+        const permissions = generatePermissions(analysis);
+        const settings: Record<string, unknown> = { permissions };
+
+        // Determine project commands for hook generation
+        const testCommand = analysis.testCommands?.test || analysis.testCommands?.["test:unit"] || "npm test";
+        const lintCommand = analysis.linter
+          ? analysis.linter === "ESLint" ? "npx eslint" : "npx biome lint"
+          : "npx eslint";
+        const formatCommand = analysis.formatter
+          ? analysis.formatter === "Prettier" ? "npx prettier --write"
+            : analysis.formatter === "Biome" ? "npx @biomejs/biome format --write"
+            : analysis.formatter === "Ruff" ? "ruff format"
+            : analysis.formatter === "Black" ? "black"
+            : "npx prettier --write"
+          : "npx prettier --write";
+
+        // Generate hooks based on strictness profile
+        const profileHooks = getHooksForProfile(
+          effectiveStrictness,
+          testCommand,
+          lintCommand,
+          formatCommand
+        );
+        const hooksConfig = hooksToSettingsFormat(profileHooks);
+        settings.hooks = hooksConfig;
+
+        const hookCount = profileHooks.length;
+        const settingsContent = JSON.stringify(settings, null, 2);
+        const settingsPath = sanitizePath(absPath, ".claude/settings.json");
+        await safeWriteFile(settingsPath, settingsContent, false);
+        generatedFiles.push({
+          path: ".claude/settings.json",
+          content: settingsContent,
+          description: `${hookCount} enforcement hooks (strictness: ${effectiveStrictness})`,
+        });
+
+        // 6. Generate agents based on project type
+        const agentTemplates = ["explore", "plan", "test-runner"];
+        for (const agent of agentTemplates) {
+          try {
+            const agentContent = await loadTemplate("agents", agent);
+            const agentPath = sanitizePath(absPath, `.claude/agents/${agent}.md`);
+            await safeWriteFile(agentPath, agentContent, false);
+            generatedFiles.push({ path: `.claude/agents/${agent}.md`, content: agentContent, description: `${agent} subagent` });
+          } catch {
+            // Template not found, skip
+          }
+        }
+
+        // 7. Generate .mcp.json stub
+        const mcpConfig = { mcpServers: {} };
+        const mcpPath = sanitizePath(absPath, ".mcp.json");
+        await safeWriteFile(mcpPath, JSON.stringify(mcpConfig, null, 2), false);
+        generatedFiles.push({ path: ".mcp.json", content: JSON.stringify(mcpConfig, null, 2), description: "MCP server configuration" });
+
+        // 8. Multi-platform configuration generation
+        const projectName = path.basename(absPath);
+        const platformResults: Record<string, GeneratedFile[]> = {};
+
+        // Cursor support
+        if (targetPlatforms.includes("cursor")) {
+          const cursorFiles = await generateCursorConfig(
+            absPath,
+            projectName,
+            claudemd,
+            getDefaultCursorSkills()
+          );
+          platformResults.cursor = cursorFiles;
+          generatedFiles.push(...cursorFiles);
+        }
+
+        // Windsurf support
+        if (targetPlatforms.includes("windsurf")) {
+          const windsurfFiles = await generateWindsurfConfig(
+            absPath,
+            claudemd,
+            getDefaultWindsurfRules()
+          );
+          platformResults.windsurf = windsurfFiles;
+          generatedFiles.push(...windsurfFiles);
+        }
+
+        // Codex CLI support
+        if (targetPlatforms.includes("codex")) {
+          const codexFiles = await generateCodexConfig(absPath, projectName, claudemd);
+          platformResults.codex = codexFiles;
+          generatedFiles.push(...codexFiles);
+        }
+
+        // Build the analysis summary
+        const analysisSummary = summarizeAnalysis(analysis);
+
+        const filesSummary = generatedFiles
+          .map((f) => `  ${f.path} — ${f.description}`)
+          .join("\n");
+
+        // Build platform summary
+        const platformSummary = targetPlatforms.map((p) => {
+          const files = p === "claude-code"
+            ? generatedFiles.filter((f) => f.path.startsWith("CLAUDE.md") || f.path.startsWith(".claude"))
+            : platformResults[p] || [];
+          return `• ${p}: ${files.length} files`;
+        }).join("\n");
+
+        return makeResult(
+          `## Rebar Project Initialized\n\n` +
+          `**Project:** ${absPath}\n` +
+          `**Platforms:** ${targetPlatforms.join(", ")}\n` +
+          `**Strictness:** ${effectiveStrictness}\n\n` +
+          `### Analysis\n${analysisSummary}\n\n` +
+          `### Platforms Configured\n${platformSummary}\n\n` +
+          `### Enforcement\n` +
+          `• ${hookCount} hooks installed (strictness: ${effectiveStrictness})\n` +
+          (effectiveStrictness === "standard" ? "• Test/lint failures notify but don't block\n" : "") +
+          (effectiveStrictness === "strict" ? "• Test/lint failures BLOCK until fixed\n" : "") +
+          (effectiveStrictness === "paranoid" ? "• All quality checks BLOCK, plus file size limits and type safety\n" : "") +
+          `\n### Generated Files\n${filesSummary}\n\n` +
+          `### Next Steps\n` +
+          `1. Review CLAUDE.md — it's ready to use but you know your project best\n` +
+          `2. rebar_create_skill to add domain-specific skills\n` +
+          (effectiveStrictness === "standard" ? `3. rebar_set_strictness to increase enforcement to 'strict' or 'paranoid'\n` : "") +
+          (compliance && compliance.length > 0
+            ? `4. rebar_apply_compliance to generate ${compliance.join(", ").toUpperCase()} artifacts\n`
+            : "") +
+          (team_size > 10
+            ? `5. Consider rebar_create_ci_workflow for automated PR reviews (team of ${team_size})\n`
+            : "")
+        );
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        return makeResult(
+          `Failed to initialize project: ${message}\n\n` +
+          `Suggestions:\n` +
+          `• Ensure ${absPath} exists and is writable\n` +
+          `• Check that the directory contains a project manifest (package.json, Cargo.toml, etc.)\n` +
+          `• If it's a new project, create the directory first and add a package.json`,
+          true
+        );
+      }
+    }
+  );
+
+  // ─── rebar_generate_claudemd ─────────────────────────────────────
+  server.registerTool(
+    "rebar_generate_claudemd",
+    {
+      title: "Generate CLAUDE.md",
+      description:
+        "[Rebar] Creates a deeply customized CLAUDE.md by analyzing your actual project. Reads package.json, " +
+        "detects frameworks, finds real build/test/lint commands, identifies ORMs, CSS frameworks, " +
+        "state management, auth libraries, and generates architecture rules specific to your stack.\n\n" +
+        "The output reflects what your project actually IS — not a generic template.\n\n" +
+        "Examples:\n" +
+        "  rebar_generate_claudemd({ project_path: '.', scope: 'root' })\n" +
+        "  rebar_generate_claudemd({ project_path: './apps/web', scope: 'subdir', merge_existing: true })\n" +
+        "  rebar_generate_claudemd({ project_path: '.', tech_stack: ['nextjs', 'express'] })\n\n" +
+        "Returns: Path to generated file, detected stack summary, line count.\n" +
+        "Error: Returns if no tech stack detected (suggests providing tech_stack parameter).",
+      inputSchema: GenerateClaudeMDInputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const { project_path, scope, tech_stack, merge_existing } = args;
+      const absPath = resolveProjectPath(project_path);
+
+      try {
+        const analysis = await analyzeProject(absPath);
+
+        // Override with user-provided stacks
+        if (tech_stack) {
+          for (const stack of tech_stack) {
+            if (!analysis.stacks.includes(stack as typeof analysis.stacks[number])) {
+              analysis.stacks.push(stack as typeof analysis.stacks[number]);
+            }
+          }
+        }
+
+        if (analysis.stacks.length === 0 && analysis.language === "unknown") {
+          return makeResult(
+            "Could not detect your project's tech stack.\n\n" +
+            "This usually means:\n" +
+            "• No package.json, Cargo.toml, go.mod, or pom.xml was found\n" +
+            "• The project directory might be empty or misconfigured\n\n" +
+            "Fix: Provide the tech_stack parameter explicitly:\n" +
+            '  rebar_generate_claudemd({ project_path: ".", tech_stack: ["nextjs"] })\n\n' +
+            "Supported stacks: nextjs, react, vue, angular, svelte, express, fastapi, django, flask, springboot, go, rust, dotnet",
+            true
+          );
+        }
+
+        const content = generateClaudeMD(analysis);
+        const claudemdPath = scope === "subdir"
+          ? sanitizePath(absPath, "CLAUDE.md")
+          : sanitizePath(absPath, "CLAUDE.md");
+
+        const result = await safeWriteFile(claudemdPath, content, merge_existing);
+        const lineCount = content.split("\n").length;
+        const analysisSummary = summarizeAnalysis(analysis);
+
+        return makeResult(
+          `${result.message}\n\n` +
+          `── What was detected ──\n${analysisSummary}\n\n` +
+          `── Generated ──\n` +
+          `Lines: ${lineCount}\n` +
+          `Sections: Tech Stack, Architecture Rules, Build & Test, ` +
+          `${analysis.sourceDirs.length > 0 ? "File Structure, " : ""}` +
+          `Code Conventions` +
+          `${analysis.database ? ", Database" : ""}` +
+          `${analysis.envVarNames.length > 0 ? ", Environment Variables" : ""}\n\n` +
+          (result.merged ? "Note: Merged with existing CLAUDE.md (previous content was replaced).\n" : "") +
+          `Review and customize — this is your project's AI instruction manual.`
+        );
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        return makeResult(`Failed to generate CLAUDE.md: ${message}`, true);
+      }
+    }
+  );
+
+  // ─── rebar_create_skill ──────────────────────────────────────────
+  server.registerTool(
+    "rebar_create_skill",
+    {
+      title: "Create Skill",
+      description:
+        "[Rebar] Scaffolds a production-ready skill in .claude/skills/<name>/ with SKILL.md containing " +
+        "valid YAML frontmatter. Skills are reusable AI capabilities — code review, test generation, " +
+        "documentation, security scanning, etc.\n\n" +
+        "The YAML frontmatter controls behavior:\n" +
+        "• invocation: 'user' (slash command), 'auto' (triggered by context), 'both'\n" +
+        "• context: 'inline' (runs in main session), 'fork' (runs in subagent)\n" +
+        "• allowed_tools: restricts which tools the skill can use\n\n" +
+        "Examples:\n" +
+        "  rebar_create_skill({ name: 'code-review', description: 'Reviews code changes for quality and security', invocation: 'auto', context: 'fork', allowed_tools: ['Read', 'Grep', 'Glob'] })\n" +
+        "  rebar_create_skill({ name: 'db-migrate', description: 'Generates and applies database migrations', invocation: 'user', context: 'inline', allowed_tools: ['Read', 'Write', 'Bash'] })\n\n" +
+        "Returns: Skill location, frontmatter summary, next steps.\n" +
+        "Error: If skill name already exists (suggests different name).",
+      inputSchema: CreateSkillInputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const { name, description, invocation, context, agent_type, allowed_tools } = args;
+      const skillDir = path.join(process.cwd(), ".claude", "skills", name);
+
+      try {
+        if (await fileExists(skillDir)) {
+          return makeResult(
+            `Skill "${name}" already exists at ${skillDir}\n\n` +
+            `Options:\n` +
+            `• Use a different name\n` +
+            `• Remove the existing skill directory and try again\n` +
+            `• Edit the existing SKILL.md directly`,
+            true
+          );
+        }
+
+        await ensureDir(skillDir);
+
+        // Try to load a matching template for common skill types
+        let templateBody = "";
+        const templateNames = ["code-review", "test-writer", "documentation", "security-scan", "performance-audit"];
+        for (const tpl of templateNames) {
+          if (name.includes(tpl.split("-")[0])) {
+            try {
+              const fullTemplate = await loadTemplate("skills", tpl);
+              // Extract just the body (after frontmatter)
+              const bodyMatch = fullTemplate.match(/^---[\s\S]*?---\s*([\s\S]*)$/);
+              if (bodyMatch) templateBody = bodyMatch[1].trim();
+              break;
+            } catch {
+              // No template found, that's fine
+            }
+          }
+        }
+
+        // Build YAML frontmatter
+        const frontmatterLines = [
+          "---",
+          `name: ${name}`,
+          `description: ${description}`,
+          `invocation: ${invocation}`,
+          `context: ${context}`,
+        ];
+        if (agent_type) {
+          frontmatterLines.push(`agent_type: ${agent_type}`);
+        }
+        if (allowed_tools && allowed_tools.length > 0) {
+          frontmatterLines.push("allowed_tools:");
+          for (const tool of allowed_tools) {
+            frontmatterLines.push(`  - ${tool}`);
+          }
+        }
+        frontmatterLines.push("---");
+
+        const body = templateBody || (
+          `# ${name}\n\n` +
+          `${description}\n\n` +
+          "## Instructions\n\n" +
+          "<!-- Replace this with your skill instructions.\n" +
+          "Good skill instructions:\n" +
+          "1. Define the agent's role clearly\n" +
+          "2. Specify the exact output format\n" +
+          "3. List what to check/do step by step\n" +
+          "4. Include examples of good output\n" +
+          "-->\n"
+        );
+
+        const skillContent = frontmatterLines.join("\n") + "\n\n" + body + "\n";
+
+        const skillPath = path.join(skillDir, "SKILL.md");
+        await atomicWrite(skillPath, skillContent);
+
+        const invocationHint = invocation === "user"
+          ? `Invoke with: /${name}`
+          : invocation === "auto"
+            ? "Will trigger automatically based on context"
+            : `Invoke with: /${name} (also triggers automatically)`;
+
+        return makeResult(
+          `Skill created: ${name}\n\n` +
+          `Location: ${skillDir}/SKILL.md\n` +
+          `${invocationHint}\n` +
+          `Context: ${context === "fork" ? "Runs in isolated subagent" : "Runs in main session"}\n` +
+          (allowed_tools && allowed_tools.length > 0 ? `Tools: ${allowed_tools.join(", ")}\n` : "") +
+          (templateBody ? "\nPre-filled with a matching template — customize as needed.\n" : "\nEdit the SKILL.md to add your instructions.\n")
+        );
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        return makeResult(`Failed to create skill: ${message}`, true);
+      }
+    }
+  );
+
+  // ─── rebar_create_agent ──────────────────────────────────────────
+  server.registerTool(
+    "rebar_create_agent",
+    {
+      title: "Create Agent",
+      description:
+        "[Rebar] Scaffolds a subagent definition in .claude/agents/. Subagents are specialized AI workers " +
+        "with restricted tool access and focused system prompts.\n\n" +
+        "Built-in roles with smart defaults:\n" +
+        "• explore: Read-only codebase investigation (Read, Grep, Glob)\n" +
+        "• plan: Architecture planning without code changes (Read, Grep, Glob)\n" +
+        "• general: Full-capability agent\n" +
+        "• custom: Blank template for custom behavior\n\n" +
+        "Examples:\n" +
+        "  rebar_create_agent({ name: 'security-auditor', description: 'Scans for OWASP vulnerabilities', role: 'explore' })\n" +
+        "  rebar_create_agent({ name: 'db-migrator', description: 'Plans and executes database migrations', role: 'general', allowed_tools: ['Read', 'Write', 'Bash'] })\n\n" +
+        "Returns: Agent file path, role, next steps.\n" +
+        "Error: If agent name already exists.",
+      inputSchema: CreateAgentInputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const { name, description, role, allowed_tools, model_hint } = args;
+      const agentDir = path.join(process.cwd(), ".claude", "agents");
+      const agentPath = path.join(agentDir, `${name}.md`);
+
+      try {
+        if (await fileExists(agentPath)) {
+          return makeResult(
+            `Agent "${name}" already exists at ${agentPath}\n\n` +
+            `Options:\n` +
+            `• Use a different name\n` +
+            `• Remove the existing agent file and try again\n` +
+            `• Edit the existing file directly`,
+            true
+          );
+        }
+
+        await ensureDir(agentDir);
+
+        // Try to load a role-based template
+        let content: string;
+        try {
+          content = await loadTemplate("agents", role === "custom" ? "explore" : role);
+          content = `# ${name}\n\n${description}\n\n` + content.split("\n").slice(3).join("\n");
+        } catch {
+          const toolsList = allowed_tools && allowed_tools.length > 0
+            ? allowed_tools.map((t) => `- ${t}`).join("\n")
+            : "- Read\n- Grep\n- Glob";
+
+          content =
+            `# ${name}\n\n` +
+            `${description}\n\n` +
+            `## Role\n${getRoleDescription(role)}\n\n` +
+            `## Allowed Tools\n${toolsList}\n` +
+            (model_hint ? `\n## Model Hint\nPreferred model: ${model_hint}\n` : "") +
+            "\n## Guidelines\n" +
+            "- Be thorough and systematic\n" +
+            "- Report findings with file paths and line numbers\n" +
+            "- Provide actionable recommendations\n";
+        }
+
+        await atomicWrite(agentPath, content);
+
+        return makeResult(
+          `Agent created: ${name}\n\n` +
+          `Location: ${agentPath}\n` +
+          `Role: ${role}\n` +
+          `Description: ${description}\n` +
+          (model_hint ? `Model hint: ${model_hint}\n` : "") +
+          `\nThis agent will be available as a subagent type in Claude Code.\n` +
+          `Edit ${agentPath} to customize its behavior.`
+        );
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        return makeResult(`Failed to create agent: ${message}`, true);
+      }
+    }
+  );
+
+  // ─── rebar_create_hook ───────────────────────────────────────────
+  server.registerTool(
+    "rebar_create_hook",
+    {
+      title: "Create Hook",
+      description:
+        "[Rebar] Adds a lifecycle hook to .claude/settings.json. Hooks run shell commands in response to " +
+        "Claude Code events — format code after writes, lint changes, block dangerous commands, etc.\n\n" +
+        "Supported events:\n" +
+        "• PreToolCall: Before a tool executes (use to block or validate)\n" +
+        "• PostToolCall: After a tool executes (use to format, lint, test)\n" +
+        "• Notification: On status notifications\n" +
+        "• Stop: When Claude stops generating\n" +
+        "• SubagentStop: When a subagent stops\n" +
+        "• PreCompact: Before context compaction\n" +
+        "• PostCompact: After context compaction\n" +
+        "• SessionStart: When a new session begins\n\n" +
+        "Environment variables available: $TOOL_INPUT_COMMAND, $TOOL_INPUT_FILE_PATH, etc.\n\n" +
+        "Examples:\n" +
+        '  rebar_create_hook({ event: "PostToolCall", matcher: "Write|Edit", command: \'npx prettier --write "$TOOL_INPUT_FILE_PATH"\', exit_behavior: "notify", description: "Format on write" })\n' +
+        '  rebar_create_hook({ event: "PreToolCall", matcher: "Bash", command: \'echo "$TOOL_INPUT_COMMAND" | grep -qE "rm -rf|DROP TABLE" && exit 1\', exit_behavior: "block", description: "Block dangerous commands" })\n\n' +
+        "Returns: Hook details, updated settings path.\n" +
+        "Idempotent: Re-running with same command+matcher updates the existing hook.",
+      inputSchema: CreateHookInputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const { event, matcher, command, exit_behavior, description } = args;
+      const settingsPath = path.join(process.cwd(), ".claude", "settings.json");
+
+      try {
+        let settings: Record<string, unknown> = {};
+        const existing = await readFileSafe(settingsPath);
+        if (existing) {
+          settings = JSON.parse(existing) as Record<string, unknown>;
+        }
+
+        if (!settings.hooks) settings.hooks = {};
+        const hooks = settings.hooks as Record<string, unknown[]>;
+        if (!hooks[event]) hooks[event] = [];
+
+        const hookEntry: Record<string, unknown> = { description, command, exit_behavior };
+        if (matcher) hookEntry.matcher = matcher;
+
+        const eventHooks = hooks[event] as Record<string, unknown>[];
+        const existingIdx = eventHooks.findIndex(
+          (h) => h.command === command && h.matcher === matcher
+        );
+
+        const isUpdate = existingIdx >= 0;
+        if (isUpdate) {
+          eventHooks[existingIdx] = hookEntry;
+        } else {
+          eventHooks.push(hookEntry);
+        }
+
+        await ensureDir(path.dirname(settingsPath));
+        await atomicWrite(settingsPath, JSON.stringify(settings, null, 2));
+
+        return makeResult(
+          `Hook ${isUpdate ? "updated" : "added"}: ${description}\n\n` +
+          `Event: ${event}\n` +
+          (matcher ? `Matcher: ${matcher}\n` : "All tool calls\n") +
+          `Command: ${command}\n` +
+          `On failure: ${exit_behavior === "block" ? "BLOCKS the action" : "Shows notification"}\n\n` +
+          `Updated: ${settingsPath}`
+        );
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        return makeResult(`Failed to create hook: ${message}`, true);
+      }
+    }
+  );
+
+  // ─── rebar_create_command ────────────────────────────────────────
+  server.registerTool(
+    "rebar_create_command",
+    {
+      title: "Create Command",
+      description:
+        "[Rebar] Creates a slash command (e.g., /review, /deploy, /docs) as a skill with user invocation. " +
+        "Slash commands are the primary way teams standardize Claude Code workflows.\n\n" +
+        "When a user types /command-name, Claude receives the prompt_body as instructions.\n\n" +
+        "Examples:\n" +
+        '  rebar_create_command({ name: "review", description: "Review current changes", prompt_body: "Review the current git diff. Check for security issues, performance problems, and code quality. Output findings as Critical/Warning/Suggestion." })\n' +
+        '  rebar_create_command({ name: "deploy-check", description: "Pre-deploy checklist", prompt_body: "Run through the deployment checklist: 1. All tests pass 2. No TODO/FIXME in changed files 3. No console.log statements 4. Database migrations are reversible", arguments: [{ name: "env", description: "Target environment", required: true }] })\n\n' +
+        "Returns: Slash command usage, file location.\n" +
+        "Error: If command name already exists.",
+      inputSchema: CreateCommandInputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const { name, description, prompt_body, arguments: cmdArgs } = args;
+      const skillDir = path.join(process.cwd(), ".claude", "skills", name);
+
+      try {
+        if (await fileExists(skillDir)) {
+          return makeResult(
+            `Command "/${name}" already exists at ${skillDir}\n\n` +
+            `Options:\n` +
+            `• Use a different name\n` +
+            `• Remove the existing skill directory and try again\n` +
+            `• Edit the existing SKILL.md directly`,
+            true
+          );
+        }
+
+        await ensureDir(skillDir);
+
+        const frontmatterLines = [
+          "---",
+          `name: ${name}`,
+          `description: ${description}`,
+          "invocation: user",
+          "context: inline",
+          "---",
+        ];
+
+        let argsSection = "";
+        if (cmdArgs && cmdArgs.length > 0) {
+          argsSection =
+            "\n## Arguments\n\n" +
+            cmdArgs
+              .map((a) => `- **${a.name}**${a.required ? " (required)" : " (optional)"}: ${a.description}`)
+              .join("\n") +
+            "\n";
+        }
+
+        const content =
+          frontmatterLines.join("\n") +
+          "\n\n" +
+          `# /${name}\n\n` +
+          `${description}\n` +
+          argsSection +
+          "\n## Prompt\n\n" +
+          prompt_body +
+          "\n";
+
+        const skillPath = path.join(skillDir, "SKILL.md");
+        await atomicWrite(skillPath, content);
+
+        return makeResult(
+          `Command created: /${name}\n\n` +
+          `Location: ${skillPath}\n` +
+          `Description: ${description}\n` +
+          (cmdArgs && cmdArgs.length > 0
+            ? `Arguments: ${cmdArgs.map((a) => `${a.name}${a.required ? "" : "?"}`).join(", ")}\n`
+            : "") +
+          `\nUsage: Type /${name} in Claude Code to invoke this command.`
+        );
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        return makeResult(`Failed to create command: ${message}`, true);
+      }
+    }
+  );
+
+  // ─── rebar_set_strictness ───────────────────────────────────────────
+  server.registerTool(
+    "rebar_set_strictness",
+    {
+      title: "Set Rebar Strictness Profile",
+      description:
+        "[Rebar] Changes the enforcement strictness level for the current project. Rewrites the hooks " +
+        "in .claude/settings.json to match the selected profile.\n\n" +
+        "Profiles:\n" +
+        "• standard: Hooks notify on issues but don't block (except dangerous commands and secrets)\n" +
+        "• strict: Hooks block on test/lint failures\n" +
+        "• paranoid: All strict hooks + file size limits, any-type blocking, commit completeness\n\n" +
+        "Examples:\n" +
+        "  rebar_set_strictness({ project_path: '.', strictness: 'strict' })\n" +
+        "  rebar_set_strictness({ project_path: '.', strictness: 'paranoid' })\n\n" +
+        "Idempotent: Safe to run multiple times.",
+      inputSchema: SetStrictnessInputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const { project_path, strictness, output_format } = args;
+      const absPath = resolveProjectPath(project_path);
+      const settingsPath = sanitizePath(absPath, ".claude/settings.json");
+
+      try {
+        // Read existing settings
+        const existingContent = await readFileSafe(settingsPath);
+        let settings: Record<string, unknown> = {};
+        if (existingContent) {
+          settings = JSON.parse(existingContent) as Record<string, unknown>;
+        }
+
+        // Detect current profile
+        const currentHooks = (settings.hooks || {}) as Record<string, unknown[]>;
+        const currentProfile = detectCurrentProfile(currentHooks);
+
+        // Detect project commands (try to read from package.json or use defaults)
+        let testCommand = "npm test";
+        let lintCommand = "npx eslint";
+        let formatCommand = "npx prettier --write";
+
+        const pkgPath = sanitizePath(absPath, "package.json");
+        const pkgContent = await readFileSafe(pkgPath);
+        if (pkgContent) {
+          const pkg = JSON.parse(pkgContent) as Record<string, unknown>;
+          const scripts = (pkg.scripts || {}) as Record<string, string>;
+          if (scripts.test) testCommand = `npm run test`;
+          if (scripts.lint) lintCommand = `npm run lint --`;
+          if (scripts.format) formatCommand = `npm run format --`;
+        }
+
+        // Generate new hooks for the target profile
+        const newHooks = getHooksForProfile(
+          strictness as StrictnessProfile,
+          testCommand,
+          lintCommand,
+          formatCommand
+        );
+        const hooksConfig = hooksToSettingsFormat(newHooks);
+
+        // Update settings with new hooks
+        settings.hooks = hooksConfig;
+
+        // Write back atomically
+        await ensureDir(path.dirname(settingsPath));
+        await atomicWrite(settingsPath, JSON.stringify(settings, null, 2));
+
+        const hookCount = newHooks.length;
+        const profileDescriptions: Record<string, string> = {
+          standard: "Tests/lint notify but don't block. Dangerous commands and secrets always blocked.",
+          strict: "Tests and lint failures BLOCK. All standard protections apply.",
+          paranoid: "Maximum enforcement: tests, lint, file size (400 lines), any types, and TODOs all block.",
+        };
+
+        if (output_format === "json") {
+          return makeResult(JSON.stringify({
+            success: true,
+            previous_profile: currentProfile,
+            new_profile: strictness,
+            hooks_count: hookCount,
+            settings_path: settingsPath,
+          }, null, 2));
+        }
+
+        return makeResult(
+          `Strictness updated: ${currentProfile || "unknown"} → ${strictness}\n\n` +
+          `${profileDescriptions[strictness]}\n\n` +
+          `Hooks installed: ${hookCount}\n` +
+          `Settings updated: ${settingsPath}\n\n` +
+          (strictness === "paranoid"
+            ? "⚠️ Paranoid mode is strict. Files over 400 lines, 'any' types, and TODO comments will block commits.\n"
+            : "")
+        );
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        return makeResult(`Failed to set strictness: ${message}`, true);
+      }
+    }
+  );
+}
+
+function getRoleDescription(role: string): string {
+  switch (role) {
+    case "explore":
+      return "You are an exploration agent. Search and read code without making any changes. Report findings with exact file paths and line numbers.";
+    case "plan":
+      return "You are a software architect. Analyze requirements, examine existing code, and create detailed implementation plans. Never write or modify code directly.";
+    case "general":
+      return "You are a general-purpose coding agent. Handle tasks as directed, from code changes to testing to documentation.";
+    case "custom":
+      return "You are a specialized agent. Follow the custom instructions provided below.";
+    default:
+      return "You are an agent. Follow the instructions provided.";
+  }
+}