rebar-mcp 2.0.0

package/src/tests/enforcement.test.ts

@@ -0,0 +1,794 @@
+/**
+ * Enforcement layer tests for v1.2.0
+ * Tests for templates, code quality audit, and hook templates
+ */
+import { describe, it, before } from "node:test";
+import * as assert from "node:assert";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+  createTestDir,
+  createMockProject,
+  readTestFile,
+  testFileExists,
+  assertToolSuccess,
+  getToolResultText,
+  parseToolResultJson,
+} from "./test-utils.js";
+import { initializeTools, invokeTool } from "./tool-harness.js";
+
+// Initialize tools before all tests
+before(() => {
+  initializeTools();
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SECTION 7.1: Template Content Tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("Template Content Tests", () => {
+  describe("CLAUDE.md templates", () => {
+    const templateDir = path.join(process.cwd(), "templates/claudemd");
+
+    it("should contain required sections in nextjs.md", async () => {
+      const content = await fs.readFile(path.join(templateDir, "nextjs.md"), "utf-8");
+
+      assert.ok(
+        content.includes("## Tech Stack"),
+        "Template should contain Tech Stack header"
+      );
+      assert.ok(
+        content.includes("## Build & Test"),
+        "Template should contain Build & Test header"
+      );
+      assert.ok(
+        content.includes("## Architecture Rules"),
+        "Template should contain Architecture Rules header"
+      );
+      assert.ok(
+        content.includes("## Code Conventions"),
+        "Template should contain Code Conventions header"
+      );
+    });
+
+    it("should contain required sections in fastapi.md", async () => {
+      const content = await fs.readFile(path.join(templateDir, "fastapi.md"), "utf-8");
+
+      assert.ok(
+        content.includes("##"),
+        "Template should contain section headers"
+      );
+      assert.ok(
+        content.length > 200,
+        "Template should have substantial content"
+      );
+    });
+
+    it("should contain required sections in springboot.md", async () => {
+      const content = await fs.readFile(path.join(templateDir, "springboot.md"), "utf-8");
+
+      assert.ok(
+        content.includes("##"),
+        "Template should contain section headers"
+      );
+      assert.ok(
+        content.length > 200,
+        "Template should have substantial content"
+      );
+    });
+
+    it("should contain required sections in react-spa.md", async () => {
+      const content = await fs.readFile(path.join(templateDir, "react-spa.md"), "utf-8");
+
+      assert.ok(
+        content.includes("##"),
+        "Template should contain section headers"
+      );
+      assert.ok(
+        content.length > 200,
+        "Template should have substantial content"
+      );
+    });
+
+    it("should contain required sections in monorepo.md", async () => {
+      const content = await fs.readFile(path.join(templateDir, "monorepo.md"), "utf-8");
+
+      assert.ok(
+        content.includes("##"),
+        "Template should contain section headers"
+      );
+      assert.ok(
+        content.length > 200,
+        "Template should have substantial content"
+      );
+    });
+
+    it("should have valid Handlebars variable syntax in templates", async () => {
+      const templates = ["nextjs.md", "fastapi.md", "springboot.md", "react-spa.md", "monorepo.md"];
+
+      for (const template of templates) {
+        const content = await fs.readFile(path.join(templateDir, template), "utf-8");
+
+        // Check that all variables use proper Handlebars syntax
+        const variableMatches = content.match(/\{\{[^}]+\}\}/g) || [];
+
+        for (const match of variableMatches) {
+          // Should be valid Handlebars: {{var}}, {{#if var}}, {{/if}}, {{#each var}}, {{/each}}, {{#unless var}}, {{/unless}}, {{this}}, {{#if has_foo}}
+          assert.ok(
+            /^\{\{(#if\s+[\w_]+|#each\s+[\w_]+|#unless\s+[\w_]+|\/if|\/each|\/unless|else|this|[\w_]+)\}\}$/.test(match),
+            `Invalid variable syntax in ${template}: ${match}`
+          );
+        }
+      }
+    });
+  });
+
+  describe("Skill templates", () => {
+    const templateDir = path.join(process.cwd(), "templates/skills");
+    const skillTemplates = ["code-review.md", "test-writer.md", "security-scan.md", "documentation.md", "performance-audit.md"];
+
+    for (const template of skillTemplates) {
+      it(`should have valid YAML frontmatter in ${template}`, async () => {
+        const content = await fs.readFile(path.join(templateDir, template), "utf-8");
+
+        // Check for YAML frontmatter
+        assert.ok(
+          content.startsWith("---\n"),
+          `${template} should start with YAML frontmatter`
+        );
+
+        const frontmatterEnd = content.indexOf("\n---\n", 4);
+        assert.ok(
+          frontmatterEnd > 0,
+          `${template} should have closing frontmatter marker`
+        );
+
+        const frontmatter = content.substring(4, frontmatterEnd);
+
+        // Check required fields (name and description are required per Claude Code spec)
+        assert.ok(
+          frontmatter.includes("name:"),
+          `${template} frontmatter should have name field`
+        );
+        assert.ok(
+          frontmatter.includes("description:"),
+          `${template} frontmatter should have description field`
+        );
+      });
+
+      it(`should have detailed instructions in ${template}`, async () => {
+        const content = await fs.readFile(path.join(templateDir, template), "utf-8");
+
+        // Should have substantial content (not just placeholders)
+        assert.ok(
+          content.length > 500,
+          `${template} should have substantial content (>500 chars), got ${content.length}`
+        );
+
+        // Should not contain generic placeholder text (but TODO in instructions to user is ok)
+        assert.ok(
+          !content.includes("add appropriate content"),
+          `${template} should not contain generic placeholder text`
+        );
+      });
+    }
+  });
+
+  describe("Agent templates", () => {
+    const templateDir = path.join(process.cwd(), "templates/agents");
+    const agentTemplates = ["explore.md", "plan.md", "test-runner.md", "security-auditor.md"];
+
+    for (const template of agentTemplates) {
+      it(`should have valid markdown structure in ${template}`, async () => {
+        const content = await fs.readFile(path.join(templateDir, template), "utf-8");
+
+        // Agent templates use markdown format (not YAML frontmatter)
+        // Check for valid markdown structure with headers
+        assert.ok(
+          content.startsWith("# "),
+          `${template} should start with a markdown header`
+        );
+
+        // Should have role or purpose section
+        assert.ok(
+          content.includes("## "),
+          `${template} should have subsections`
+        );
+      });
+
+      it(`should have detailed instructions in ${template}`, async () => {
+        const content = await fs.readFile(path.join(templateDir, template), "utf-8");
+
+        // Should have substantial content
+        assert.ok(
+          content.length > 300,
+          `${template} should have substantial content (>300 chars), got ${content.length}`
+        );
+      });
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SECTION 7.2: Code Quality Audit Tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+// TODO: Implement rebar_audit_code_quality tool
+describe.skip("rebar_audit_code_quality", () => {
+  it("should detect TODO comments", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      // Create file with TODO
+      await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+      await fs.writeFile(
+        path.join(testDir, "src/todo-test.ts"),
+        `// TODO: implement this later
+export function incomplete() {
+  return null;
+}
+`
+      );
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const issues = data.issues as Array<Record<string, unknown>>;
+
+      const todoIssue = issues.find(i => i.category === "Incomplete Work");
+      assert.ok(todoIssue, "Should detect TODO comment");
+      assert.strictEqual(todoIssue.severity, "MEDIUM");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should detect empty catch blocks", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+      await fs.writeFile(
+        path.join(testDir, "src/empty-catch.ts"),
+        `export function badErrorHandling() {
+  try {
+    throw new Error("oops");
+  } catch (e) {}
+}
+`
+      );
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const issues = data.issues as Array<Record<string, unknown>>;
+
+      const catchIssue = issues.find(i => i.category === "Empty Catch Block");
+      assert.ok(catchIssue, "Should detect empty catch block");
+      assert.strictEqual(catchIssue.severity, "HIGH");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should detect any type usage", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      // Create a file with explicit any type usage
+      await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+      const anyTypeContent = `// Test file for any type detection
+export function unsafeFunction(data: any) {
+  return data.foo;
+}
+
+const value: any = "test";
+`;
+      await fs.writeFile(path.join(testDir, "src/any-type.ts"), anyTypeContent);
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        language: "typescript", // Explicitly set language to avoid auto-detection issues
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const issues = data.issues as Array<Record<string, unknown>>;
+      const scannedFiles = data.scanned_files as number;
+
+      // Verify files were scanned
+      assert.ok(scannedFiles > 0, `Should scan at least 1 file, got ${scannedFiles}`);
+
+      const anyIssue = issues.find(i => i.category === "Type Safety");
+      assert.ok(anyIssue, `Should detect any type usage. Issues found: ${JSON.stringify(issues.map(i => i.category))}`);
+      assert.strictEqual(anyIssue.severity, "HIGH");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should detect console.log in production code", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+      await fs.writeFile(
+        path.join(testDir, "src/debug-code.ts"),
+        `export function process() {
+  console.log("debugging here");
+  return 42;
+}
+`
+      );
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const issues = data.issues as Array<Record<string, unknown>>;
+
+      const consoleIssue = issues.find(i => i.category === "Debug Code");
+      assert.ok(consoleIssue, "Should detect console.log");
+      assert.strictEqual(consoleIssue.severity, "MEDIUM");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should detect large files (>400 lines)", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+
+      // Create a file with 450 lines
+      const lines: string[] = [];
+      lines.push("export const largeFile = {");
+      for (let i = 0; i < 445; i++) {
+        lines.push(`  prop${i}: ${i},`);
+      }
+      lines.push("};");
+      lines.push("");
+
+      await fs.writeFile(path.join(testDir, "src/large-file.ts"), lines.join("\n"));
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const issues = data.issues as Array<Record<string, unknown>>;
+
+      const largeFileIssue = issues.find(i => i.category === "Large File");
+      assert.ok(largeFileIssue, "Should detect large file");
+      assert.strictEqual(largeFileIssue.severity, "MEDIUM");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should detect hardcoded secrets", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+      await fs.writeFile(
+        path.join(testDir, "src/secrets.ts"),
+        `// Bad practice!
+const apiKey = "sk-proj-1234567890abcdefghijklmnop";
+
+export function getKey() {
+  return apiKey;
+}
+`
+      );
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const issues = data.issues as Array<Record<string, unknown>>;
+
+      const secretIssue = issues.find(i => i.category === "Hardcoded Secret");
+      assert.ok(secretIssue, "Should detect hardcoded secret");
+      assert.strictEqual(secretIssue.severity, "CRITICAL");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should calculate quality score correctly", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+
+      // Create file with known issues:
+      // 1 CRITICAL (hardcoded secret) = -15
+      // 1 HIGH (empty catch) = -5
+      // 1 MEDIUM (TODO) = -2
+      // Expected score: 100 - 15 - 5 - 2 = 78
+      await fs.writeFile(
+        path.join(testDir, "src/multi-issues.ts"),
+        `// TODO: fix this
+const apiKey = "sk-1234567890abcdefghijklmnopqrs";
+
+export function bad() {
+  try {
+    throw new Error();
+  } catch (e) {}
+  return apiKey;
+}
+`
+      );
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const score = data.score as number;
+
+      // Score = 100 - 15 (critical) - 5 (high) - 2 (medium) = 78
+      assert.ok(score <= 78, `Expected score <= 78 but got ${score}`);
+      assert.ok(score >= 70, `Expected score >= 70 but got ${score}`);
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should return markdown output format", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        output_format: "markdown",
+      });
+
+      assertToolSuccess(result);
+
+      const text = getToolResultText(result);
+      assert.ok(text.includes("## Code Quality Audit Report"), "Should have markdown header");
+      assert.ok(text.includes("| Severity | Count |"), "Should have summary table");
+      assert.ok(text.includes("### Quality Score"), "Should have quality score section");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should skip test files for console.log detection", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+
+      // console.log in test file should be allowed
+      await fs.writeFile(
+        path.join(testDir, "src/helper.test.ts"),
+        `import { helper } from "./helper";
+
+test("helper works", () => {
+  console.log("debugging test");
+  expect(helper()).toBe(true);
+});
+`
+      );
+
+      const result = await invokeTool("rebar_audit_code_quality", {
+        project_path: testDir,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const issues = data.issues as Array<Record<string, unknown>>;
+
+      const consoleIssue = issues.find(
+        i => i.category === "Debug Code" && (i.file as string).includes("helper.test.ts")
+      );
+      assert.ok(!consoleIssue, "Should NOT flag console.log in test files");
+    } finally {
+      await cleanup();
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SECTION 7.3: Hook Template Tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("Hook Template Tests", () => {
+  const templateDir = path.join(process.cwd(), "templates/hooks");
+  const validEvents = ["PreToolCall", "PostToolCall"];
+
+  // Hook templates that actually exist
+  const hookTemplates = [
+    "format-on-write.json",
+    "lint-on-write.json",
+    "danger-blocker.json",
+    "secret-detector.json",
+  ];
+
+  for (const template of hookTemplates) {
+    describe(template, () => {
+      it("should be valid JSON", async () => {
+        const content = await fs.readFile(path.join(templateDir, template), "utf-8");
+
+        assert.doesNotThrow(
+          () => JSON.parse(content),
+          `${template} should be valid JSON`
+        );
+      });
+
+      it("should have valid hook structure", async () => {
+        const content = await fs.readFile(path.join(templateDir, template), "utf-8");
+        const parsed = JSON.parse(content) as Record<string, unknown>;
+
+        // New template structure: { description, hooks: [{ event, matcher, command, exit_behavior }] }
+        assert.ok(typeof parsed.description === "string", `${template}: Should have description`);
+        assert.ok(Array.isArray(parsed.hooks), `${template}: Should have hooks array`);
+
+        const hooks = parsed.hooks as Array<Record<string, unknown>>;
+        for (const hook of hooks) {
+          assert.ok(
+            validEvents.includes(hook.event as string),
+            `${template}: Event "${hook.event}" must be one of: ${validEvents.join(", ")}`
+          );
+          assert.ok(typeof hook.matcher === "string", `${template}: Hook should have matcher string`);
+          assert.ok(typeof hook.command === "string", `${template}: Hook should have command string`);
+          assert.ok(
+            ["notify", "block"].includes(hook.exit_behavior as string),
+            `${template}: exit_behavior should be "notify" or "block"`
+          );
+        }
+      });
+    });
+  }
+
+  describe("danger-blocker.json specific tests", () => {
+    it("should have Bash matcher and block exit behavior", async () => {
+      const content = await fs.readFile(path.join(templateDir, "danger-blocker.json"), "utf-8");
+      const parsed = JSON.parse(content) as Record<string, unknown>;
+      const hooks = parsed.hooks as Array<Record<string, unknown>>;
+
+      const bashHook = hooks.find(h => h.matcher === "Bash");
+      assert.ok(bashHook, "Should have Bash matcher hook");
+      assert.strictEqual(bashHook.exit_behavior, "block", "Should block dangerous commands");
+      assert.strictEqual(bashHook.event, "PreToolCall", "Should run before tool call");
+    });
+  });
+
+  describe("secret-detector.json specific tests", () => {
+    it("should have Bash matcher for secret detection", async () => {
+      const content = await fs.readFile(path.join(templateDir, "secret-detector.json"), "utf-8");
+      const parsed = JSON.parse(content) as Record<string, unknown>;
+      const hooks = parsed.hooks as Array<Record<string, unknown>>;
+
+      const bashHook = hooks.find(h => h.matcher === "Bash");
+      assert.ok(bashHook, "Should have Bash matcher hook");
+      assert.strictEqual(bashHook.exit_behavior, "block", "Should block commits with secrets");
+    });
+  });
+
+  describe("format-on-write.json specific tests", () => {
+    it("should have PostToolCall event for formatting", async () => {
+      const content = await fs.readFile(path.join(templateDir, "format-on-write.json"), "utf-8");
+      const parsed = JSON.parse(content) as Record<string, unknown>;
+      const hooks = parsed.hooks as Array<Record<string, unknown>>;
+
+      assert.ok(hooks.length > 0, "Should have at least one hook");
+      const hook = hooks[0];
+      assert.strictEqual(hook.event, "PostToolCall", "Should run after tool call");
+      assert.ok(
+        (hook.matcher as string).includes("Write") || (hook.matcher as string).includes("Edit"),
+        "Should match Write or Edit tools"
+      );
+
+      // Should have variants for different formatters
+      const variants = parsed.variants as Record<string, string>;
+      assert.ok(variants, "Should have formatter variants");
+      assert.ok(variants.prettier, "Should have prettier variant");
+    });
+  });
+
+  describe("lint-on-write.json specific tests", () => {
+    it("should have PostToolCall event for linting", async () => {
+      const content = await fs.readFile(path.join(templateDir, "lint-on-write.json"), "utf-8");
+      const parsed = JSON.parse(content) as Record<string, unknown>;
+      const hooks = parsed.hooks as Array<Record<string, unknown>>;
+
+      assert.ok(hooks.length > 0, "Should have at least one hook");
+      const hook = hooks[0];
+      assert.strictEqual(hook.event, "PostToolCall", "Should run after tool call");
+      assert.strictEqual(hook.exit_behavior, "block", "Should block on lint errors");
+
+      // Should have variants for different linters
+      const variants = parsed.variants as Record<string, string>;
+      assert.ok(variants, "Should have linter variants");
+      assert.ok(variants.eslint, "Should have eslint variant");
+    });
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Integration: rebar_init_project installs enforcement
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("rebar_init_project enforcement installation", () => {
+  it("should install all hook templates", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      // Create minimal package.json
+      await fs.writeFile(
+        path.join(testDir, "package.json"),
+        JSON.stringify({ name: "test", version: "1.0.0" })
+      );
+
+      const result = await invokeTool("rebar_init_project", {
+        project_path: testDir,
+        tech_stack: ["node"],
+        team_size: 5,
+      });
+
+      assertToolSuccess(result);
+
+      // Check settings.json has hooks
+      const settingsContent = await readTestFile(testDir, ".claude/settings.json");
+      assert.ok(settingsContent, "Should create settings.json");
+
+      const settings = JSON.parse(settingsContent);
+
+      // Check for hook events
+      assert.ok(
+        settings.hooks?.PreToolUse || settings.hooks?.PostToolUse,
+        "Settings should have hooks configured"
+      );
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should install all skill templates", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await fs.writeFile(
+        path.join(testDir, "package.json"),
+        JSON.stringify({ name: "test", version: "1.0.0" })
+      );
+
+      const result = await invokeTool("rebar_init_project", {
+        project_path: testDir,
+        tech_stack: ["node"],
+        team_size: 5,
+      });
+
+      assertToolSuccess(result);
+
+      // Check for skills
+      const skillsDir = path.join(testDir, ".claude/skills");
+      const expectedSkills = ["code-review", "test-writer", "security-scan", "documentation", "performance-audit"];
+
+      for (const skill of expectedSkills) {
+        const skillExists = await testFileExists(testDir, `.claude/skills/${skill}/SKILL.md`);
+        assert.ok(skillExists, `Should install ${skill} skill`);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should install all agent templates", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await fs.writeFile(
+        path.join(testDir, "package.json"),
+        JSON.stringify({ name: "test", version: "1.0.0" })
+      );
+
+      const result = await invokeTool("rebar_init_project", {
+        project_path: testDir,
+        tech_stack: ["node"],
+        team_size: 5,
+      });
+
+      assertToolSuccess(result);
+
+      // Check for agents
+      const expectedAgents = ["explore.md", "plan.md", "test-runner.md", "security-auditor.md"];
+
+      for (const agent of expectedAgents) {
+        const agentExists = await testFileExists(testDir, `.claude/agents/${agent}`);
+        assert.ok(agentExists, `Should install ${agent} agent`);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should create CLAUDE.md with essential sections", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await fs.writeFile(
+        path.join(testDir, "package.json"),
+        JSON.stringify({ name: "test", version: "1.0.0" })
+      );
+
+      const result = await invokeTool("rebar_init_project", {
+        project_path: testDir,
+        tech_stack: ["node"],
+        team_size: 5,
+      });
+
+      assertToolSuccess(result);
+
+      const claudemd = await readTestFile(testDir, "CLAUDE.md");
+      assert.ok(claudemd, "Should create CLAUDE.md");
+
+      // Check for essential sections in generated CLAUDE.md
+      assert.ok(
+        claudemd.includes("##") && claudemd.length > 100,
+        "CLAUDE.md should have sections and substantial content"
+      );
+    } finally {
+      await cleanup();
+    }
+  });
+});