rebar-mcp 2.0.0

package/src/tests/scaffolding.test.ts

@@ -0,0 +1,575 @@
+/**
+ * Integration tests for scaffolding tools
+ * rebar_init_project, rebar_generate_claudemd, rebar_create_skill,
+ * rebar_create_agent, rebar_create_hook, rebar_create_command
+ */
+import { describe, it, before, after } from "node:test";
+import * as assert from "node:assert";
+import {
+  createTestDir,
+  createMockProject,
+  readTestFile,
+  testFileExists,
+  readTestJson,
+  assertToolSuccess,
+  assertToolError,
+  getToolResultText,
+  parseToolResultJson,
+} from "./test-utils.js";
+import { initializeTools, invokeTool } from "./tool-harness.js";
+
+// Initialize tools before all tests
+before(() => {
+  initializeTools();
+});
+
+describe("rebar_init_project", () => {
+  it("should initialize a new project with all required files", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      const result = await invokeTool("rebar_init_project", {
+        project_path: testDir,
+        tech_stack: ["express"],
+        team_size: 5,
+      });
+
+      assertToolSuccess(result);
+
+      // Check CLAUDE.md was created
+      assert.ok(
+        await testFileExists(testDir, "CLAUDE.md"),
+        "CLAUDE.md should be created"
+      );
+
+      // Check .claudeignore was created
+      assert.ok(
+        await testFileExists(testDir, ".claudeignore"),
+        ".claudeignore should be created"
+      );
+
+      // Check .claude/settings.json was created
+      assert.ok(
+        await testFileExists(testDir, ".claude/settings.json"),
+        ".claude/settings.json should be created"
+      );
+
+      // Check .mcp.json was created
+      assert.ok(
+        await testFileExists(testDir, ".mcp.json"),
+        ".mcp.json should be created"
+      );
+
+      // Verify settings.json structure
+      const settings = await readTestJson<Record<string, unknown>>(
+        testDir,
+        ".claude/settings.json"
+      );
+      assert.ok(settings, "settings.json should be valid JSON");
+      assert.ok(settings.permissions, "settings should have permissions");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should return JSON output when output_format is json", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      const result = await invokeTool("rebar_init_project", {
+        project_path: testDir,
+        tech_stack: ["express"],
+        team_size: 5,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      assert.strictEqual(parsed.success, true);
+      assert.strictEqual(parsed.operation, "init_project");
+      assert.ok(parsed.data, "JSON should have data field");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should support dry_run mode", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      const result = await invokeTool("rebar_init_project", {
+        project_path: testDir,
+        tech_stack: ["express"],
+        team_size: 5,
+        dry_run: true,
+      });
+
+      assertToolSuccess(result);
+
+      const text = getToolResultText(result);
+      assert.ok(text.includes("DRY RUN"), "Should indicate dry run");
+
+      // CLAUDE.md should NOT be created in dry-run mode
+      assert.ok(
+        !(await testFileExists(testDir, "CLAUDE.md")),
+        "CLAUDE.md should NOT be created in dry-run mode"
+      );
+    } finally {
+      await cleanup();
+    }
+  });
+});
+
+describe("rebar_generate_claudemd", () => {
+  it("should generate CLAUDE.md from project analysis", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      const result = await invokeTool("rebar_generate_claudemd", {
+        project_path: testDir,
+      });
+
+      assertToolSuccess(result);
+
+      const claudemd = await readTestFile(testDir, "CLAUDE.md");
+      assert.ok(claudemd, "CLAUDE.md should be created");
+      assert.ok(claudemd.includes("#"), "Should have markdown headings");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should detect tech stack from package.json", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir, {
+        packageJson: {
+          name: "nextjs-app",
+          dependencies: {
+            next: "^14.0.0",
+            react: "^18.0.0",
+          },
+        },
+      });
+
+      const result = await invokeTool("rebar_generate_claudemd", {
+        project_path: testDir,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      const data = parsed.data as Record<string, unknown>;
+      const analysis = data.analysis as Record<string, unknown>;
+      assert.ok(
+        (analysis.stacks as string[]).includes("nextjs") ||
+          (analysis.stacks as string[]).includes("react"),
+        "Should detect Next.js or React"
+      );
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should support dry_run mode", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      await createMockProject(testDir);
+
+      const result = await invokeTool("rebar_generate_claudemd", {
+        project_path: testDir,
+        dry_run: true,
+        output_format: "json",
+      });
+
+      assertToolSuccess(result);
+
+      const parsed = parseToolResultJson<Record<string, unknown>>(result);
+      assert.strictEqual(parsed.dry_run, true);
+
+      // File should not exist
+      assert.ok(
+        !(await testFileExists(testDir, "CLAUDE.md")),
+        "CLAUDE.md should NOT be created in dry-run"
+      );
+    } finally {
+      await cleanup();
+    }
+  });
+});
+
+describe("rebar_create_skill", () => {
+  it("should create a new skill directory with SKILL.md", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      // Change to test directory for process.cwd() usage
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_skill", {
+          name: "test-skill",
+          description: "A test skill for unit testing",
+        });
+
+        assertToolSuccess(result);
+
+        assert.ok(
+          await testFileExists(testDir, ".claude/skills/test-skill/SKILL.md"),
+          "SKILL.md should be created"
+        );
+
+        const skillContent = await readTestFile(
+          testDir,
+          ".claude/skills/test-skill/SKILL.md"
+        );
+        assert.ok(skillContent, "Skill file should have content");
+        assert.ok(skillContent.includes("name: test-skill"), "Should have name in frontmatter");
+        assert.ok(
+          skillContent.includes("A test skill for unit testing"),
+          "Should have description"
+        );
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should fail if skill already exists", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        // Create first skill
+        await invokeTool("rebar_create_skill", {
+          name: "existing-skill",
+          description: "First skill",
+        });
+
+        // Try to create again
+        const result = await invokeTool("rebar_create_skill", {
+          name: "existing-skill",
+          description: "Duplicate skill",
+        });
+
+        assertToolError(result);
+        const text = getToolResultText(result);
+        assert.ok(text.includes("already exists"), "Should mention already exists");
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should support dry_run mode", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_skill", {
+          name: "dry-run-skill",
+          description: "Should not be created",
+          dry_run: true,
+        });
+
+        assertToolSuccess(result);
+
+        assert.ok(
+          !(await testFileExists(testDir, ".claude/skills/dry-run-skill/SKILL.md")),
+          "Skill should NOT be created in dry-run"
+        );
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+});
+
+describe("rebar_create_agent", () => {
+  it("should create a new agent file", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_agent", {
+          name: "test-agent",
+          description: "A test agent for unit testing",
+          role: "explore",
+        });
+
+        assertToolSuccess(result);
+
+        assert.ok(
+          await testFileExists(testDir, ".claude/agents/test-agent.md"),
+          "Agent file should be created"
+        );
+
+        const agentContent = await readTestFile(
+          testDir,
+          ".claude/agents/test-agent.md"
+        );
+        assert.ok(agentContent, "Agent file should have content");
+        assert.ok(agentContent.includes("test-agent"), "Should include agent name");
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should fail if agent already exists", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        // Create first agent
+        await invokeTool("rebar_create_agent", {
+          name: "existing-agent",
+          description: "First agent",
+          role: "explore",
+        });
+
+        // Try to create again
+        const result = await invokeTool("rebar_create_agent", {
+          name: "existing-agent",
+          description: "Duplicate agent",
+          role: "plan",
+        });
+
+        assertToolError(result);
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+});
+
+describe("rebar_create_hook", () => {
+  it("should add a hook to settings.json", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_hook", {
+          event: "PreToolCall",
+          command: "echo test",
+          description: "Test hook",
+          exit_behavior: "notify",
+        });
+
+        assertToolSuccess(result);
+
+        const settings = await readTestJson<Record<string, unknown>>(
+          testDir,
+          ".claude/settings.json"
+        );
+        assert.ok(settings, "settings.json should exist");
+        assert.ok(settings.hooks, "Should have hooks");
+
+        const hooks = settings.hooks as Record<string, unknown[]>;
+        assert.ok(hooks.PreToolCall, "Should have PreToolCall hooks");
+        assert.ok(
+          hooks.PreToolCall.some(
+            (h: unknown) => (h as Record<string, unknown>).command === "echo test"
+          ),
+          "Should contain the new hook"
+        );
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should update existing hook with same command and matcher", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        // Create first hook
+        await invokeTool("rebar_create_hook", {
+          event: "PreToolCall",
+          command: "echo test",
+          matcher: "Bash",
+          description: "First description",
+          exit_behavior: "notify",
+        });
+
+        // Update with same command and matcher but different description and exit_behavior
+        const result = await invokeTool("rebar_create_hook", {
+          event: "PreToolCall",
+          command: "echo test",
+          matcher: "Bash",
+          description: "Updated description",
+          exit_behavior: "block",
+        });
+
+        assertToolSuccess(result);
+
+        const text = getToolResultText(result);
+        assert.ok(text.includes("updated"), "Should indicate update");
+
+        const settings = await readTestJson<Record<string, unknown>>(
+          testDir,
+          ".claude/settings.json"
+        );
+        const hooks = settings?.hooks as Record<string, unknown[]>;
+        const preToolCallHooks = hooks?.PreToolCall ?? [];
+
+        // Should only have one hook with that command
+        const matchingHooks = preToolCallHooks.filter(
+          (h: unknown) =>
+            (h as Record<string, unknown>).command === "echo test"
+        );
+        assert.strictEqual(matchingHooks.length, 1, "Should have exactly one hook");
+        assert.strictEqual(
+          (matchingHooks[0] as Record<string, unknown>).description,
+          "Updated description",
+          "Hook description should be updated"
+        );
+        assert.strictEqual(
+          (matchingHooks[0] as Record<string, unknown>).exit_behavior,
+          "block",
+          "Hook exit_behavior should be updated"
+        );
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+});
+
+describe("rebar_create_command", () => {
+  it("should create a command skill", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_command", {
+          name: "test-cmd",
+          description: "A test command",
+          prompt_body: "Do something useful",
+        });
+
+        assertToolSuccess(result);
+
+        assert.ok(
+          await testFileExists(testDir, ".claude/skills/test-cmd/SKILL.md"),
+          "Command skill should be created"
+        );
+
+        const skillContent = await readTestFile(
+          testDir,
+          ".claude/skills/test-cmd/SKILL.md"
+        );
+        assert.ok(skillContent, "Skill file should have content");
+        assert.ok(skillContent.includes("invocation: user"), "Should be user-invoked");
+        assert.ok(skillContent.includes("Do something useful"), "Should include prompt");
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should include arguments in command", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_command", {
+          name: "cmd-with-args",
+          description: "Command with arguments",
+          prompt_body: "Process the input",
+          arguments: [
+            { name: "target", description: "Target to process", required: true },
+            { name: "mode", description: "Processing mode", required: false },
+          ],
+        });
+
+        assertToolSuccess(result);
+
+        const skillContent = await readTestFile(
+          testDir,
+          ".claude/skills/cmd-with-args/SKILL.md"
+        );
+        assert.ok(skillContent, "Skill file should have content");
+        assert.ok(skillContent.includes("**target**"), "Should include target arg");
+        assert.ok(skillContent.includes("(required)"), "Should mark required");
+        assert.ok(skillContent.includes("(optional)"), "Should mark optional");
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+});