@arii/boomtick-mcp 0.3.6 → 0.4.0

package/.mcp/schemas/github.create_issue.json

@@ -30,6 +30,19 @@
       ],
       "default": null,
       "title": "File"
+    },
+    "repo": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "The target repository override (e.g. org/repo).",
+      "title": "Repo"
     }
   },
   "required": [

package/.mcp/schemas/github.create_pull_request.json

@@ -26,6 +26,19 @@
       "description": "Whether to create the PR as a draft.",
       "title": "Draft",
       "type": "boolean"
+    },
+    "repo": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "The target repository override (e.g. org/repo).",
+      "title": "Repo"
     }
   },
   "required": [

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.4.0](https://github.com/arii/boomtick/compare/mcp-v0.3.7...mcp-v0.4.0) (2026-09-04)
+
+
+### Features
+
+* **impact:** add targeted route and viewport options for visual diff… ([#775](https://github.com/arii/boomtick/issues/775)) ([c767fd4](https://github.com/arii/boomtick/commit/c767fd47063ce6a1078a728c3af79bcf18e2c5c5))
+
+## [0.3.7](https://github.com/arii/boomtick/compare/mcp-v0.3.6...mcp-v0.3.7) (2026-08-17)
+
+
+### Bug Fixes
+
+* **ci:** remove submodule-pinned action refs from impact-analysis ([#723](https://github.com/arii/boomtick/issues/723)) ([d6e0494](https://github.com/arii/boomtick/commit/d6e0494fe8ac781777fb1546bb3c0f0102074a5c))
+* ensure impact analysis posts PR comments and sends Jules messages ([#724](https://github.com/arii/boomtick/issues/724)) ([a52cc8e](https://github.com/arii/boomtick/commit/a52cc8e220def8bf2057b4da1b596e80fc0eed1f))
+* resolve script fallback paths in mcp impact-analysis action ([#716](https://github.com/arii/boomtick/issues/716)) ([b29dd06](https://github.com/arii/boomtick/commit/b29dd067da2b45fc8410ca26e34a8c74626fe937))
+
 ## [0.3.6](https://github.com/arii/boomtick/compare/mcp-v0.3.5...mcp-v0.3.6) (2026-08-13)
 
 

package/actions/ai-review/action.yml

@@ -16,5 +16,5 @@ runs:
           echo "::error::Invalid PR_NUMBER: must be numeric."
           exit 1
         fi
-        td-cli gh audit-pr "$PR_NUMBER" --fetch --audit
+        td-cli gh audit-pr "$PR_NUMBER" --fetch --audit --submit --execute
       shell: bash

package/actions/impact-analysis/action.yml

@@ -16,10 +16,8 @@ inputs:
 runs:
   using: composite
   steps:
-    - uses: arii/boomtick/mcp/actions/setup@main
-
-    - name: pnpm install
-      run: pnpm install --frozen-lockfile --prefer-offline
+    - name: Configure Git Safe Directory
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
       shell: bash
 
     - name: Validate PR Number
@@ -173,8 +171,13 @@ runs:
           echo "Executing check-visual-changes.ts at: $RESOLVED_PATH"
           pnpm exec tsx "$RESOLVED_PATH" >> "$GITHUB_OUTPUT"
         else
-          echo "⚠️ Skipping: check-visual-changes.ts script not found. Defaulting changed_routes=0"
-          echo "changed_routes=0" >> "$GITHUB_OUTPUT"
+          if [ -f "scripts/check-visual-changes.ts" ]; then
+            echo "Executing check-visual-changes.ts from current workspace."
+            pnpm exec tsx scripts/check-visual-changes.ts >> "$GITHUB_OUTPUT"
+          else
+            echo "⚠️ Skipping: check-visual-changes.ts script not found. Defaulting changed_routes=0"
+            echo "changed_routes=0" >> "$GITHUB_OUTPUT"
+          fi
         fi
       shell: bash
 
@@ -194,21 +197,6 @@ runs:
         fi
       shell: bash
 
-    - name: Visual review github models agent
-      if: always() && steps.check_visuals.outputs.changed_routes != '0' && steps.check_visuals.outputs.changed_routes != ''
-      env:
-        GITHUB_TOKEN: ${{ inputs.github_token }}
-        PR_NUMBER: ${{ inputs.pr_number }}
-        JULES_API_KEY: ${{ inputs.jules_api_key }}
-        GITHUB_REPOSITORY: ${{ github.repository }}
-      run: |
-        if node -e "const pkg = require('./package.json'); if (!pkg.scripts || !pkg.scripts['impact:github-models-review']) process.exit(1)" 2>/dev/null; then
-          pnpm run impact:github-models-review
-        else
-          echo "⚠️ Skipping: impact:github-models-review script not found"
-        fi
-      shell: bash
-
     - name: Report Summary
       if: always()
       run: |
@@ -241,26 +229,20 @@ runs:
         if [ -f artifacts/gemini-review.md ]; then
           { echo ""; cat artifacts/gemini-review.md; } >> "$GITHUB_STEP_SUMMARY"
         fi
-        if [ -f artifacts/github-models-review.md ]; then
-          { echo ""; cat artifacts/github-models-review.md; } >> "$GITHUB_STEP_SUMMARY"
-        fi
         if [ -f artifacts/gemini-code-review.md ]; then
           { echo ""; cat artifacts/gemini-code-review.md; } >> "$GITHUB_STEP_SUMMARY"
         fi
-        if [ -f artifacts/github-models-code-review.md ]; then
-          { echo ""; cat artifacts/github-models-code-review.md; } >> "$GITHUB_STEP_SUMMARY"
-        fi
 
         FAILED=0
-        # Expected verdicts: gemini-code-review, github-models-code-review
+        # Expected verdicts: gemini-code-review
         # Visual reviews are expected only if visual changes exist
         EXPECTED_REVIEWS=""
         if [ "${{ steps.impact_analysis.outputs.has_impact }}" == "true" ]; then
           if [ "${{ github.event_name }}" == "pull_request" ]; then
-            EXPECTED_REVIEWS="gemini-code-review github-models-code-review"
+            EXPECTED_REVIEWS="gemini-code-review"
           fi
           if [ "${{ steps.check_visuals.outputs.changed_routes }}" != "0" ] && [ "${{ steps.check_visuals.outputs.changed_routes }}" != "" ]; then
-            EXPECTED_REVIEWS="$EXPECTED_REVIEWS gemini-review github-models-review"
+            EXPECTED_REVIEWS="$EXPECTED_REVIEWS gemini-review"
           fi
         fi
 
@@ -328,19 +310,100 @@ runs:
         if [ -f "$TARGET_PATH" ]; then
           RESOLVED_PATH=$(realpath "$TARGET_PATH")
           echo "Executing send-jules-impact.py at: $RESOLVED_PATH"
+          export PYTHONPATH="$(realpath "${{ github.action_path }}/../../../cli"):$PYTHONPATH"
           python3 "$RESOLVED_PATH"
         else
-          echo "⚠️ Skipping: send-jules-impact.py script not found."
+          # Fallback check for docker run execution or direct python script in checkout workspace
+          # Inside container execution, scripts/send-jules-impact.py should exist in workspace
+          if [ -f "scripts/send-jules-impact.py" ]; then
+            echo "Executing send-jules-impact.py from current workspace."
+            export PYTHONPATH="cli:$PYTHONPATH"
+            python3 scripts/send-jules-impact.py
+          else
+            echo "⚠️ Skipping: send-jules-impact.py script not found."
+          fi
         fi
       shell: bash
 
     - name: Update Impact Analysis Feedback (Final Result)
       if: always()
-      uses: arii/boomtick/mcp/actions/update-pr-comment@main
+      uses: actions/github-script@v8 # nosemgrep: yaml.github-actions.security.github-actions-mutable-action-tag.github-actions-mutable-action-tag
+      env:
+        INPUT_STATUS_LINE: '✅ **Impact Analysis Complete**'
+        INPUT_IMPACT_BODY: ${{ env.IMPACT_BODY }}
       with:
-        github_token: ${{ inputs.github_token }}
-        status_line: '✅ **Impact Analysis Complete**'
-        impact_body: ${{ env.IMPACT_BODY }}
+        github-token: ${{ inputs.github_token }}
+        script: |
+          const owner = context.repo.owner;
+          const repo = context.repo.repo;
+          const branchName = context.ref.replace('refs/heads/', '');
+
+          const pstTime = new Date().toLocaleString('en-US', {
+            timeZone: 'America/Los_Angeles',
+            dateStyle: 'medium',
+            timeStyle: 'short'
+          });
+
+          if (branchName === 'main') return;
+
+          const pullRequests = await github.paginate(github.rest.pulls.list, {
+            owner,
+            repo,
+            state: 'open'
+          });
+          const matchingPRs = pullRequests.filter(pr => pr.head.ref === branchName);
+
+          const statusLine = process.env.INPUT_STATUS_LINE;
+          let impactBodyText = (process.env.INPUT_IMPACT_BODY || '')
+            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '[REMOVED SCRIPT]');
+
+          for (const pr of matchingPRs) {
+            const commentTag = `<!-- impact-analysis-comment-${branchName} -->`;
+            let bodyParts = [
+              `🚀 **Impact Analysis Details** (Last updated: ${pstTime} PST)`,
+              '',
+              statusLine,
+              `- **Commit SHA:** \`${process.env.GITHUB_SHA.slice(0, 7)}\``,
+              `- [Link to artifacts](https://github.com/${owner}/${repo}/actions/runs/${context.runId})`,
+              ''
+            ];
+
+            if (impactBodyText) {
+              bodyParts.push(impactBodyText, '');
+            }
+
+            const MAX_LENGTH = 65536;
+            const truncationNotice = '\n\n... (truncated due to GitHub comment size limits)\n';
+            let currentContent = bodyParts.join('\n');
+            let projectedLength = currentContent.length + commentTag.length + 1;
+
+            if (projectedLength > MAX_LENGTH) {
+              const availableLength = MAX_LENGTH - commentTag.length - truncationNotice.length - 2;
+              let safeContent = currentContent.slice(0, availableLength);
+              let lastNewline = safeContent.lastIndexOf('\n');
+              if (lastNewline > availableLength * 0.9) {
+                safeContent = safeContent.slice(0, lastNewline);
+              }
+              bodyParts = [safeContent, truncationNotice];
+            }
+
+            bodyParts.push(commentTag);
+            const body = bodyParts.join('\n');
+
+            const comments = await github.paginate(github.rest.issues.listComments, {
+              owner,
+              repo,
+              issue_number: pr.number,
+            });
+
+            const existingComment = comments.find(c => c.body.includes(commentTag));
+
+            if (existingComment) {
+              await github.rest.issues.updateComment({ owner, repo, comment_id: existingComment.id, body });
+            } else {
+              await github.rest.issues.createComment({ issue_number: pr.number, owner, repo, body });
+            }
+          }
 
     - name: Merge AI Logs into Artifacts
       if: always()

package/dist/config.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { execSync } from "child_process";
+vi.mock("child_process", () => ({
+    execSync: vi.fn(),
+}));
+describe("config", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        vi.resetModules();
+        process.env = { ...originalEnv };
+        vi.mocked(execSync).mockReset();
+        vi.mocked(execSync).mockReturnValue("{}");
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    describe("initializeConfig", () => {
+        it("should load dynamic config from td-cli config view", async () => {
+            const mockConfig = { github_repo: "owner/repo", base_branch: "origin/main", vite_base_path: "/app/" };
+            vi.mocked(execSync).mockReturnValue(JSON.stringify(mockConfig));
+            const { initializeConfig } = await import("./config.js");
+            const result = initializeConfig();
+            expect(execSync).toHaveBeenCalledWith("td-cli config view", expect.anything());
+            expect(result).toEqual(mockConfig);
+        });
+        it("should return cached dynamic config on subsequent calls", async () => {
+            const mockConfig = { github_repo: "owner/repo" };
+            vi.mocked(execSync).mockReturnValue(JSON.stringify(mockConfig));
+            const { initializeConfig } = await import("./config.js");
+            const result1 = initializeConfig();
+            const result2 = initializeConfig();
+            expect(result1).toBe(result2);
+            expect(execSync).toHaveBeenCalledTimes(1);
+        });
+        it("should throw critical error when execSync fails in development or CI", async () => {
+            process.env.NODE_ENV = "development";
+            vi.mocked(execSync).mockImplementation(() => {
+                throw new Error("Command failed");
+            });
+            const { initializeConfig } = await import("./config.js");
+            expect(() => initializeConfig()).toThrow(/CRITICAL: Failed to load dynamic config/);
+        });
+        it("should log warning and set empty config when execSync fails in production", async () => {
+            process.env.NODE_ENV = "production";
+            process.env.CI = "false";
+            const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+            vi.mocked(execSync).mockImplementation(() => {
+                throw new Error("Command failed");
+            });
+            const { initializeConfig } = await import("./config.js");
+            const result = initializeConfig();
+            expect(result).toEqual({});
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("CRITICAL: Failed to load dynamic config"));
+            consoleWarnSpy.mockRestore();
+        });
+    });
+    describe("config object getters", () => {
+        it("should resolve githubToken from process.env or gh CLI fallback", async () => {
+            process.env.GITHUB_TOKEN = "env-token-123";
+            const { config } = await import("./config.js");
+            expect(config.githubToken).toBe("env-token-123");
+            delete process.env.GITHUB_TOKEN;
+            vi.mocked(execSync).mockReturnValue("gh-cli-token\n");
+            expect(config.githubToken).toBe("gh-cli-token");
+            vi.mocked(execSync).mockImplementation(() => {
+                throw new Error("gh not found");
+            });
+            expect(config.githubToken).toBeUndefined();
+        });
+        it("should resolve githubOwner and githubRepo from env or cached config", async () => {
+            process.env.GITHUB_OWNER = "custom-owner";
+            process.env.GITHUB_REPO = "custom-repo";
+            const { config } = await import("./config.js");
+            expect(config.githubOwner).toBe("custom-owner");
+            expect(config.githubRepo).toBe("custom-repo");
+        });
+        it("should throw when githubOwner / githubRepo cannot be determined", async () => {
+            delete process.env.GITHUB_OWNER;
+            delete process.env.GITHUB_REPO;
+            vi.mocked(execSync).mockImplementation(() => {
+                throw new Error("td-cli failed");
+            });
+            process.env.NODE_ENV = "production";
+            process.env.CI = "false";
+            vi.spyOn(console, "warn").mockImplementation(() => { });
+            const { config, initializeConfig } = await import("./config.js");
+            initializeConfig();
+            expect(() => config.githubOwner).toThrow("GITHUB_OWNER must be set via environment variable or project_config.json");
+            expect(() => config.githubRepo).toThrow("GITHUB_REPO must be set via environment variable or project_config.json");
+        });
+        it("should resolve repoPath from BOOMTICK_REPO_PATH or findRepoRoot fallback", async () => {
+            process.env.BOOMTICK_REPO_PATH = "/custom/repo/path";
+            const { config } = await import("./config.js");
+            expect(config.repoPath).toBe("/custom/repo/path");
+        });
+        it("should resolve defaultBaseBranch, viteBasePath, and ghPath", async () => {
+            process.env.DEFAULT_BASE_BRANCH = "develop";
+            process.env.VITE_BASE_PATH = "/base/";
+            process.env.GH_PATH = "/usr/bin/gh";
+            const { config } = await import("./config.js");
+            expect(config.defaultBaseBranch).toBe("develop");
+            expect(config.viteBasePath).toBe("/base/");
+            expect(config.ghPath).toBe("/usr/bin/gh");
+        });
+        it("should throw when viteBasePath is missing", async () => {
+            delete process.env.VITE_BASE_PATH;
+            process.env.NODE_ENV = "production";
+            process.env.CI = "false";
+            vi.spyOn(console, "warn").mockImplementation(() => { });
+            const { config, initializeConfig } = await import("./config.js");
+            initializeConfig();
+            expect(() => config.viteBasePath).toThrow("VITE_BASE_PATH must be set via environment variable or project_config.json");
+        });
+    });
+});

package/dist/lib/error_utils.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "vitest";
+import { sanitizeError } from "./error_utils.js";
+describe("error_utils", () => {
+    describe("sanitizeError", () => {
+        it("should return 'Unknown error' when stderr is empty", () => {
+            expect(sanitizeError("")).toBe("Unknown error");
+        });
+        it("should return only the first line of stderr", () => {
+            const stderr = "Error: Something failed\n  at StackTrace.line1\n  at StackTrace.line2";
+            expect(sanitizeError(stderr)).toBe("Error: Something failed");
+        });
+        it("should truncate lines exceeding 200 characters", () => {
+            const longLine = "A".repeat(250);
+            const result = sanitizeError(longLine);
+            expect(result.length).toBe(200);
+            expect(result).toBe("A".repeat(200));
+        });
+        it("should preserve first line if under 200 characters", () => {
+            const line = "Fatal error: unexpected token near line 5";
+            expect(sanitizeError(line)).toBe(line);
+        });
+    });
+});

package/dist/lib/result.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { createSuccessResult, createErrorResult } from "./result.js";
+describe("result utils", () => {
+    describe("createSuccessResult", () => {
+        it("should format string data directly without JSON stringifying", () => {
+            const result = createSuccessResult("simple string message");
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: "text",
+                        text: "simple string message",
+                    },
+                ],
+            });
+            expect(result.isError).toBeUndefined();
+        });
+        it("should format object data as pretty-printed JSON string", () => {
+            const objData = { foo: "bar", count: 42 };
+            const result = createSuccessResult(objData);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(objData, null, 2),
+                    },
+                ],
+            });
+            expect(result.isError).toBeUndefined();
+        });
+    });
+    describe("createErrorResult", () => {
+        it("should format error result with message and isError set to true", () => {
+            const result = createErrorResult("Something went wrong");
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: "text",
+                        text: "Something went wrong",
+                    },
+                ],
+                isError: true,
+            });
+        });
+    });
+});

package/dist/mcp/server.test.js

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { BoomtickMCPServer } from "./server.js";
+import fs from "fs/promises";
+import * as healthModule from "./tools.js";
+import * as routeMapModule from "../tools/repo.get_route_map.js";
+import * as prDiffModule from "../tools/github.get_pr_diff.js";
+import * as ciLogsModule from "../tools/repo.read_ci_logs.js";
+import * as lighthouseModule from "../tools/repo.run_lighthouse.js";
+import * as playwrightModule from "../tools/repo.run_playwright.js";
+vi.mock("fs/promises");
+vi.mock("../config.js", () => ({
+    config: {
+        repoPath: "/mock/repo",
+    },
+}));
+describe("BoomtickMCPServer", () => {
+    let mcpServer;
+    let serverInstance;
+    let requestHandlers;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        requestHandlers = new Map();
+        mcpServer = new BoomtickMCPServer();
+        serverInstance = mcpServer.server;
+        // Retrieve registered request handlers from SDK Server instance
+        // SDK Server stores request handlers in server._requestHandlers or server.requestHandlers
+        const handlers = serverInstance._requestHandlers || serverInstance.requestHandlers;
+        if (handlers) {
+            for (const [key, handler] of handlers.entries()) {
+                requestHandlers.set(key, handler);
+            }
+        }
+    });
+    it("should instantiate server with correct name and capabilities", () => {
+        expect(serverInstance).toBeDefined();
+    });
+    describe("ListPrompts", () => {
+        it("should return prompts list", async () => {
+            const handler = requestHandlers.get("prompts/list");
+            expect(handler).toBeDefined();
+            const result = await handler({ method: "prompts/list" });
+            expect(result.prompts).toBeDefined();
+            expect(Array.isArray(result.prompts)).toBe(true);
+        });
+    });
+    describe("GetPrompt", () => {
+        it("should read prompt file and return message", async () => {
+            const handler = requestHandlers.get("prompts/get");
+            expect(handler).toBeDefined();
+            vi.mocked(fs.readFile).mockResolvedValue("You are a helpful agent.");
+            const result = await handler({
+                method: "prompts/get",
+                params: { name: "test-agent" },
+            });
+            expect(fs.readFile).toHaveBeenCalledWith("/mock/repo/mcp/src/agents/test-agent.prompt.md", "utf-8");
+            expect(result).toEqual({
+                messages: [
+                    {
+                        role: "user",
+                        content: { type: "text", text: "You are a helpful agent." },
+                    },
+                ],
+            });
+        });
+        it("should prevent path traversal attacks", async () => {
+            const handler = requestHandlers.get("prompts/get");
+            await expect(handler({
+                method: "prompts/get",
+                params: { name: "../../../etc/passwd" },
+            })).rejects.toThrow("Path traversal detected");
+        });
+        it("should throw when prompt file does not exist", async () => {
+            const handler = requestHandlers.get("prompts/get");
+            vi.mocked(fs.readFile).mockRejectedValue(new Error("File not found"));
+            await expect(handler({
+                method: "prompts/get",
+                params: { name: "nonexistent" },
+            })).rejects.toThrow("Prompt not found: nonexistent");
+        });
+    });
+    describe("ListResources", () => {
+        it("should return resources list", async () => {
+            const handler = requestHandlers.get("resources/list");
+            expect(handler).toBeDefined();
+            const result = await handler({ method: "resources/list" });
+            expect(result.resources).toBeDefined();
+            expect(Array.isArray(result.resources)).toBe(true);
+        });
+    });
+    describe("ReadResource", () => {
+        it("should handle repo://package-json", async () => {
+            const handler = requestHandlers.get("resources/read");
+            vi.mocked(fs.readFile).mockResolvedValue('{"name": "test"}');
+            const result = await handler({
+                method: "resources/read",
+                params: { uri: "repo://package-json" },
+            });
+            expect(result).toEqual({
+                contents: [{ uri: "repo://package-json", mimeType: "application/json", text: '{"name": "test"}' }],
+            });
+        });
+        it("should handle repo://routes", async () => {
+            const handler = requestHandlers.get("resources/read");
+            vi.spyOn(routeMapModule, "getRouteMapHandler").mockResolvedValue({ routes: ["/"] });
+            const result = await handler({
+                method: "resources/read",
+                params: { uri: "repo://routes" },
+            });
+            expect(result.contents[0].uri).toBe("repo://routes");
+            expect(JSON.parse(result.contents[0].text)).toEqual({ routes: ["/"] });
+        });
+        it("should handle repo://design-tokens", async () => {
+            const handler = requestHandlers.get("resources/read");
+            vi.mocked(fs.readFile).mockResolvedValue("export const tokens = {};");
+            const result = await handler({
+                method: "resources/read",
+                params: { uri: "repo://design-tokens" },
+            });
+            expect(result).toEqual({
+                contents: [{ uri: "repo://design-tokens", mimeType: "text/typescript", text: "export const tokens = {};" }],
+            });
+        });
+        it("should handle repo://diff/:prNumber", async () => {
+            const handler = requestHandlers.get("resources/read");
+            vi.spyOn(prDiffModule, "getPrDiffHandler").mockResolvedValue({ diffText: "diff --git a b" });
+            const result = await handler({
+                method: "resources/read",
+                params: { uri: "repo://diff/42" },
+            });
+            expect(result).toEqual({
+                contents: [{ uri: "repo://diff/42", mimeType: "text/plain", text: "diff --git a b" }],
+            });
+        });
+        it("should handle repo://ci/:prNumber", async () => {
+            const handler = requestHandlers.get("resources/read");
+            vi.spyOn(ciLogsModule, "readCiLogsHandler").mockResolvedValue({ status: "success" });
+            const result = await handler({
+                method: "resources/read",
+                params: { uri: "repo://ci/42" },
+            });
+            expect(result.contents[0].uri).toBe("repo://ci/42");
+            expect(JSON.parse(result.contents[0].text)).toEqual({ status: "success" });
+        });
+        it("should handle repo://lighthouse/:branch", async () => {
+            const handler = requestHandlers.get("resources/read");
+            vi.spyOn(lighthouseModule, "runLighthouseHandler").mockResolvedValue({ score: 100 });
+            const result = await handler({
+                method: "resources/read",
+                params: { uri: "repo://lighthouse/feature-x" },
+            });
+            expect(result.contents[0].uri).toBe("repo://lighthouse/feature-x");
+            expect(JSON.parse(result.contents[0].text)).toEqual({ score: 100 });
+        });
+        it("should handle repo://playwright/:branch", async () => {
+            const handler = requestHandlers.get("resources/read");
+            vi.spyOn(playwrightModule, "runPlaywrightHandler").mockResolvedValue({ passed: true });
+            const result = await handler({
+                method: "resources/read",
+                params: { uri: "repo://playwright/feature-x" },
+            });
+            expect(result.contents[0].uri).toBe("repo://playwright/feature-x");
+            expect(JSON.parse(result.contents[0].text)).toEqual({ passed: true });
+        });
+        it("should throw when resource is unknown", async () => {
+            const handler = requestHandlers.get("resources/read");
+            await expect(handler({
+                method: "resources/read",
+                params: { uri: "repo://unknown" },
+            })).rejects.toThrow("Resource not found: repo://unknown");
+        });
+    });
+    describe("ListTools", () => {
+        it("should return tools list", async () => {
+            const handler = requestHandlers.get("tools/list");
+            expect(handler).toBeDefined();
+            const result = await handler({ method: "tools/list" });
+            expect(result.tools).toBeDefined();
+            expect(Array.isArray(result.tools)).toBe(true);
+        });
+    });
+    describe("CallTool", () => {
+        it("should execute registered tool handler successfully", async () => {
+            const handler = requestHandlers.get("tools/call");
+            vi.spyOn(healthModule, "healthHandler").mockResolvedValue({ status: "ok" });
+            const result = await handler({
+                method: "tools/call",
+                params: { name: "boomtick.health", arguments: {} },
+            });
+            expect(result).toEqual({
+                content: [{ type: "text", text: JSON.stringify({ status: "ok" }, null, 2) }],
+            });
+        });
+        it("should return error result for unknown tool", async () => {
+            const handler = requestHandlers.get("tools/call");
+            const result = await handler({
+                method: "tools/call",
+                params: { name: "nonexistent.tool", arguments: {} },
+            });
+            expect(result).toEqual({
+                content: [{ type: "text", text: "Tool not found: nonexistent.tool" }],
+                isError: true,
+            });
+        });
+        it("should return error result when tool execution throws error", async () => {
+            const handler = requestHandlers.get("tools/call");
+            vi.spyOn(healthModule, "healthHandler").mockRejectedValue(new Error("Health check failed"));
+            const result = await handler({
+                method: "tools/call",
+                params: { name: "boomtick.health", arguments: {} },
+            });
+            expect(result).toEqual({
+                content: [{ type: "text", text: "Health check failed" }],
+                isError: true,
+            });
+        });
+    });
+});