boomtick-cli 0.9.0__tar.gz → 0.9.2__tar.gz

{boomtick_cli-0.9.0 → boomtick_cli-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boomtick-cli
-Version: 0.9.0
+Version: 0.9.2
 Summary: BoomTick CLI — agentic dev-tools for GitHub + AI workflows
 Author: Ariel Anders
 Project-URL: Homepage, https://github.com/arii/boomtick

{boomtick_cli-0.9.0 → boomtick_cli-0.9.2}/boomtick_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boomtick-cli
-Version: 0.9.0
+Version: 0.9.2
 Summary: BoomTick CLI — agentic dev-tools for GitHub + AI workflows
 Author: Ariel Anders
 Project-URL: Homepage, https://github.com/arii/boomtick

{boomtick_cli-0.9.0 → boomtick_cli-0.9.2}/boomtick_cli.egg-info/SOURCES.txt

@@ -26,17 +26,21 @@ dev_tools/verify_infra.py
 dev_tools/verify_versions.py
 dev_tools/version_utils.py
 dev_tools/dist/config.js
+dev_tools/dist/config.test.js
 dev_tools/dist/index.js
 dev_tools/dist/evals/run-evals.js
 dev_tools/dist/lib/error_utils.js
+dev_tools/dist/lib/error_utils.test.js
 dev_tools/dist/lib/git.js
 dev_tools/dist/lib/result.js
+dev_tools/dist/lib/result.test.js
 dev_tools/dist/lib/shell.js
 dev_tools/dist/lib/shell.test.js
 dev_tools/dist/lib/td-cli.js
 dev_tools/dist/lib/test-utils.js
 dev_tools/dist/mcp/definitions.js
 dev_tools/dist/mcp/server.js
+dev_tools/dist/mcp/server.test.js
 dev_tools/dist/mcp/tools.js
 dev_tools/dist/tools/contract.js
 dev_tools/dist/tools/ddgs.search.js
@@ -47,6 +51,7 @@ dev_tools/dist/tools/github.comment_triage_summary.js
 dev_tools/dist/tools/github.create_issue.js
 dev_tools/dist/tools/github.create_issue.test.js
 dev_tools/dist/tools/github.create_pull_request.js
+dev_tools/dist/tools/github.create_pull_request.test.js
 dev_tools/dist/tools/github.get_merge_conflict_files.js
 dev_tools/dist/tools/github.get_pr.js
 dev_tools/dist/tools/github.get_pr_diff.js
@@ -67,6 +72,7 @@ dev_tools/dist/tools/repo.get_package_scripts.test.js
 dev_tools/dist/tools/repo.get_route_map.js
 dev_tools/dist/tools/repo.logs.js
 dev_tools/dist/tools/repo.read_agent_context.js
+dev_tools/dist/tools/repo.read_agent_context.test.js
 dev_tools/dist/tools/repo.read_ci_logs.js
 dev_tools/dist/tools/repo.run_lighthouse.js
 dev_tools/dist/tools/repo.run_playwright.js
@@ -84,10 +90,12 @@ dev_tools/dist/tools/jules/list-sessions.js
 dev_tools/dist/tools/jules/send-message.js
 dev_tools/dist/tools/jules/send-message.test.js
 dev_tools/dist/tools/jules/shared.js
+dev_tools/dist/tools/jules/shared.test.js
 dev_tools/dist/tools/jules/trigger-feedback.js
 dev_tools/dist/tools/jules/trigger-feedback.test.js
 dev_tools/handlers/__init__.py
 dev_tools/handlers/command_handler.py
+dev_tools/handlers/workflow_installer.py
 dev_tools/models/__init__.py
 dev_tools/models/base.py
 dev_tools/models/contracts.py
@@ -146,4 +154,5 @@ tests/test_search_issues.py
 tests/test_verify_ci_metrics.py
 tests/test_verify_scope.py
 tests/test_workflow_audit.py
+tests/test_workflow_installer.py
 tests/test_workflow_orchestration.py

{boomtick_cli-0.9.0 → boomtick_cli-0.9.2}/dev_tools/cli-schema.json

@@ -1200,6 +1200,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": [
@@ -1350,6 +1363,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": [

{boomtick_cli-0.9.0 → boomtick_cli-0.9.2}/dev_tools/cli.py

@@ -414,13 +414,14 @@ def audit_pr(ctx, pr_number, fetch, run_audit, submit, cleanup, dry_run, base, e
 @click.option("--title", required=True, help="Issue title")
 @click.option("--file", help="Path to file containing issue body")
 @click.option("--body", help="Literal body text")
+@click.option("--repo", help="Target repository override")
 @click.pass_context
-def create_issue(ctx, title, file, body):
+def create_issue(ctx, title, file, body, repo):
     """Create a new GitHub issue."""
     orch = ctx.obj["ORCHESTRATOR"]
 
     content = _get_body_content(ctx, orch, file, body)
-    res = orch.create_issue(title, content)
+    res = orch.create_issue(title, content, repo=repo)
     out(ctx, f"✅ Successfully created issue: {res['issue'].get('html_url')}", data=res)
 
 
@@ -560,11 +561,12 @@ def scaffold_issue(ctx, file):
 @click.option("--head", required=True)
 @click.option("--base", default=PROJECT_CONFIG.base_branch_name)
 @click.option("--draft", is_flag=True)
+@click.option("--repo", help="Target repository override")
 @click.pass_context
-def create_pr(ctx, title, body, head, base, draft):
+def create_pr(ctx, title, body, head, base, draft, repo):
     """Create a new pull request."""
     orch = ctx.obj["ORCHESTRATOR"]
-    res = orch.github.create_pull_request(title, body, head, base, draft=draft)
+    res = orch.create_pull_request(title, body, head, base, draft=draft, repo=repo)
     out(ctx, f"✅ Created PR: {res.get('html_url')}", data={"pr": res})
 
 
@@ -1554,17 +1556,19 @@ def plan_workflow_audit(ctx, workflow):
 
 
 @agent_group.command(name="install-workflows")
-@click.option("--dry-run/--execute", default=True)
+@click.option("--target", default=".", help="Target directory to install workflows.")
+@click.option("--dry-run/--execute", default=True, help="Run without writing files.")
+@click.option("--force", is_flag=True, default=False, help="Overwrite existing files.")
 @click.pass_context
-def install_workflows(ctx, dry_run):
-    """Install and configure Jules/AI automation workflows for submodule or standalone use."""
-    orch = ctx.obj["ORCHESTRATOR"]
+def install_workflows(ctx, target, dry_run, force):
+    """Install and configure standardized GitHub Actions workflows."""
+    from dev_tools.handlers.workflow_installer import install_workflows as do_install
     try:
-        res = orch.install_workflows(dry_run=dry_run)
-        if res["status"] == "success":
-            out(ctx, "✅ Workflows installed successfully.", data=res)
+        success = do_install(target_dir=target, dry_run=dry_run, force=force)
+        if success:
+            out(ctx, "✅ Workflows installation complete.", data={"status": "success"})
         else:
-            out(ctx, "⚠️ Workflows partially installed or encountered errors.", data=res)
+            err(ctx, "Workflows installation failed.")
     except Exception as e:
         _handle_unexpected_error(ctx, "agent install-workflows", e)
 

{boomtick_cli-0.9.0 → boomtick_cli-0.9.2}/dev_tools/config.py

@@ -1,5 +1,4 @@
 # pylint: disable=import-outside-toplevel,line-too-long,missing-docstring,too-many-branches,too-many-instance-attributes,too-many-statements,use-maxsplit-arg,cyclic-import
-from __future__ import annotations
 import subprocess
 import re
 
@@ -13,6 +12,7 @@ from typing import Any, Dict, List, Optional
 @dataclass(frozen=True)
 class ProjectConfig:
     github_repo: str | None = None
+    package_name: str | None = None
     github_token_env: str = "GITHUB_TOKEN"
     jules_api_url: str | None = None
     core_dirs: List[str] = field(default_factory=lambda: ["src/layouts/", "src/components/"])
@@ -154,8 +154,9 @@ def load_project_config(path: str | Path = "project_config.json") -> ProjectConf
     if p.exists():
         try:
             raw = json.loads(p.read_text(encoding="utf-8"))
-        except (json.JSONDecodeError, IOError):
-            pass
+        except (json.JSONDecodeError, IOError) as e:
+            import sys
+            print(f"Warning: Failed to parse config file {p}: {e}", file=sys.stderr)
     elif str(path) == "project_config.json":
         # Check parent directories for project_config.json if not in CWD
         # This helps when running from subdirectories
@@ -166,8 +167,9 @@ def load_project_config(path: str | Path = "project_config.json") -> ProjectConf
                 try:
                     raw = json.loads(check_path.read_text(encoding="utf-8"))
                     break
-                except (json.JSONDecodeError, IOError):
-                    pass
+                except (json.JSONDecodeError, IOError) as e:
+                    import sys
+                    print(f"Warning: Failed to parse candidate config file {check_path}: {e}", file=sys.stderr)
 
     def get_list(key: str) -> Optional[List[str]]:
         val = raw.get(key)
@@ -191,6 +193,11 @@ def load_project_config(path: str | Path = "project_config.json") -> ProjectConf
     else:
         kwargs["github_repo"] = _detect_repo_name()
 
+    if "package_name" in raw:
+        kwargs["package_name"] = raw["package_name"]
+    elif "packageName" in raw:
+        kwargs["package_name"] = raw["packageName"]
+
     if "vite_base_path" in raw:
         kwargs["vite_base_path"] = raw["vite_base_path"]
     if "gh_path" in raw:

boomtick_cli-0.9.2/dev_tools/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");
+        });
+    });
+});

boomtick_cli-0.9.2/dev_tools/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);
+        });
+    });
+});

boomtick_cli-0.9.2/dev_tools/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,
+            });
+        });
+    });
+});

{boomtick_cli-0.9.0 → boomtick_cli-0.9.2}/dev_tools/dist/lib/td-cli.js

@@ -1,4 +1,31 @@
 import { runCommand } from "../lib/shell.js";
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+export const loadStandaloneAgentContext = (repoRoot = process.cwd()) => {
+    const configPath = path.join(repoRoot, "project_config.json");
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        }
+        catch (e) {
+            console.warn(`[MCP Warning] Failed to parse ${configPath}:`, e);
+        }
+    }
+    let gitCommit = "unknown";
+    try {
+        gitCommit = execSync("git rev-parse HEAD", { cwd: repoRoot, encoding: "utf-8" }).trim();
+    }
+    catch {
+        // Fallback if git is unavailable (e.g. Docker container without git)
+    }
+    return {
+        packageName: config.packageName ?? "boomtick",
+        gitCommit,
+        config,
+    };
+};
 function tryParseJson(text) {
     try {
         return JSON.parse(text);

boomtick_cli-0.9.2/dev_tools/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,
+            });
+        });
+    });
+});