@arii/boomtick-mcp 0.3.7 → 0.4.1

package/src/mcp/server.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { BoomtickMCPServer } from "./server.js";
+import { config } from "../config.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: BoomtickMCPServer;
+  let serverInstance: any;
+  let requestHandlers: Map<string, Function>;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    requestHandlers = new Map();
+
+    mcpServer = new BoomtickMCPServer();
+    serverInstance = (mcpServer as any).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: ["/"] } as any);
+
+      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" } as any);
+
+      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" } as any);
+
+      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 } as any);
+
+      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 } as any);
+
+      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" } as any);
+
+      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,
+      });
+    });
+  });
+});

package/src/tools/contract.ts

@@ -1228,7 +1228,7 @@ export const CreateBranchInputJsonSchema = {
   "type": "object"
 } as const;
 
-export const CreateIssueInputSchema = z.object({ "title": z.string().min(1), "body": z.union([z.string().min(1), z.null()]).default(null), "file": z.union([z.string().min(1), z.null()]).default(null) });
+export const CreateIssueInputSchema = z.object({ "title": z.string().min(1), "body": z.union([z.string().min(1), z.null()]).default(null), "file": z.union([z.string().min(1), z.null()]).default(null), "repo": z.union([z.string(), z.null()]).describe("The target repository override (e.g. org/repo).").default(null) });
 
 export type CreateIssueInput = z.infer<typeof CreateIssueInputSchema>;
 
@@ -1264,6 +1264,19 @@ export const CreateIssueInputJsonSchema = {
       ],
       "default": null,
       "title": "File"
+    },
+    "repo": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "The target repository override (e.g. org/repo).",
+      "title": "Repo"
     }
   },
   "required": [
@@ -1397,7 +1410,7 @@ export const CreateJulesSessionInputJsonSchema = {
   "type": "object"
 } as const;
 
-export const CreatePullRequestInputSchema = z.object({ "title": z.string().describe("PR Title."), "body": z.string().describe("Description of changes."), "head": z.string().describe("The branch containing changes to merge."), "base": z.string().describe("The target branch to merge into.").default("main"), "draft": z.boolean().describe("Whether to create the PR as a draft.").default(false) });
+export const CreatePullRequestInputSchema = z.object({ "title": z.string().describe("PR Title."), "body": z.string().describe("Description of changes."), "head": z.string().describe("The branch containing changes to merge."), "base": z.string().describe("The target branch to merge into.").default("main"), "draft": z.boolean().describe("Whether to create the PR as a draft.").default(false), "repo": z.union([z.string(), z.null()]).describe("The target repository override (e.g. org/repo).").default(null) });
 
 export type CreatePullRequestInput = z.infer<typeof CreatePullRequestInputSchema>;
 
@@ -1429,6 +1442,19 @@ export const CreatePullRequestInputJsonSchema = {
       "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/src/tools/github.create_issue.test.ts

@@ -26,12 +26,52 @@ describe("github.create_issue", () => {
       command: "td-cli gh create-issue --title 'Test Issue' --body 'Test Body'"
     });
 
-    const result = await createIssueHandler({ title: "Test Issue", body: "Test Body", file: null });
+    const result = await createIssueHandler({ title: "Test Issue", body: "Test Body", file: null, repo: null });
     expect(result.status).toBe("success");
     expect(result.issue?.number).toBe(123);
     expect(result.issue?.title).toBe("Test Issue");
   });
 
+  it("should append --repo flag when repo parameter is provided", async () => {
+    const mockResponse = {
+      status: "success",
+      issue: {
+        number: 456,
+        title: "Cross Repo Issue",
+        html_url: "https://github.com/org/other-repo/issues/456",
+        state: "open"
+      }
+    };
+
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify(mockResponse),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 10,
+      command: "td-cli gh create-issue --title 'Cross Repo Issue' --body 'Body' --repo 'org/other-repo'"
+    });
+
+    const result = await createIssueHandler({
+      title: "Cross Repo Issue",
+      body: "Body",
+      file: null,
+      repo: "org/other-repo"
+    });
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "gh",
+      "create-issue",
+      "--title",
+      "Cross Repo Issue",
+      "--body",
+      "Body",
+      "--repo",
+      "org/other-repo"
+    ]);
+    expect(result.status).toBe("success");
+    expect(result.issue?.number).toBe(456);
+  });
+
   it("should throw error on command failure", async () => {
     vi.mocked(shell.runCommand).mockResolvedValue({
       stdout: "",
@@ -41,7 +81,7 @@ describe("github.create_issue", () => {
       command: "td-cli gh create-issue"
     });
 
-    await expect(createIssueHandler({ title: "Test Issue", body: "Test Body", file: null })).rejects.toThrow("Failed to create issue: Auth failed");
+    await expect(createIssueHandler({ title: "Test Issue", body: "Test Body", file: null, repo: null })).rejects.toThrow("Failed to create issue: Auth failed");
   });
 
   it("should handle error status from CLI output", async () => {
@@ -58,6 +98,6 @@ describe("github.create_issue", () => {
       command: "td-cli gh create-issue"
     });
 
-    await expect(createIssueHandler({ title: "Test Issue", body: "Test Body", file: null })).rejects.toThrow("Failed to create issue: Repo not found");
+    await expect(createIssueHandler({ title: "Test Issue", body: "Test Body", file: null, repo: null })).rejects.toThrow("Failed to create issue: Repo not found");
   });
 });

package/src/tools/github.create_issue.ts

@@ -5,12 +5,13 @@ import { CreateIssueInputSchema, CreateIssueResponseSchema } from "./contract.js
 
 export { CreateIssueInputSchema };
 
-export async function createIssueHandler(args: z.infer<typeof CreateIssueInputSchema>) {
+export async function createIssueHandler(args: z.input<typeof CreateIssueInputSchema>) {
   const params = CreateIssueInputSchema.parse(args);
 
   const cmdArgs = ["gh", "create-issue", "--title", params.title];
   if (params.body) cmdArgs.push("--body", params.body);
   if (params.file) cmdArgs.push("--file", params.file);
+  if (params.repo) cmdArgs.push("--repo", params.repo);
 
   const result = await runCommand("td-cli", cmdArgs);
 

package/src/tools/github.create_pull_request.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi } from "vitest";
+import { createPullRequestHandler } from "./github.create_pull_request.js";
+import * as shell from "../lib/shell.js";
+
+vi.mock("../lib/shell.js", () => ({
+  runCommand: vi.fn()
+}));
+
+describe("github.create_pull_request", () => {
+  it("should create a pull request successfully", async () => {
+    const mockResponse = {
+      status: "success",
+      pr: {
+        number: 789,
+        html_url: "https://github.com/owner/repo/pull/789"
+      }
+    };
+
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify(mockResponse),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 10,
+      command: "td-cli gh create-pr --title 'PR' --body 'Body' --head 'feature' --base 'main'"
+    });
+
+    const result = await createPullRequestHandler({
+      title: "PR",
+      body: "Body",
+      head: "feature",
+      base: "main",
+      draft: false
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.url).toBe("https://github.com/owner/repo/pull/789");
+  });
+
+  it("should append --repo flag when repo parameter is provided", async () => {
+    const mockResponse = {
+      status: "success",
+      pr: {
+        number: 999,
+        html_url: "https://github.com/org/other-repo/pull/999"
+      }
+    };
+
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify(mockResponse),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 10,
+      command: "td-cli gh create-pr --title 'PR' --body 'Body' --head 'feature' --base 'main' --repo 'org/other-repo'"
+    });
+
+    const result = await createPullRequestHandler({
+      title: "PR",
+      body: "Body",
+      head: "feature",
+      base: "main",
+      draft: false,
+      repo: "org/other-repo"
+    });
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "gh",
+      "create-pr",
+      "--title",
+      "PR",
+      "--body",
+      "Body",
+      "--head",
+      "feature",
+      "--base",
+      "main",
+      "--repo",
+      "org/other-repo"
+    ]);
+    expect(result.success).toBe(true);
+    expect(result.url).toBe("https://github.com/org/other-repo/pull/999");
+  });
+
+  it("should throw error on CLI error response", async () => {
+    const mockResponse = {
+      status: "error",
+      message: "Branch not found"
+    };
+
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify(mockResponse),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 10,
+      command: "td-cli gh create-pr"
+    });
+
+    await expect(createPullRequestHandler({
+      title: "PR",
+      body: "Body",
+      head: "feature",
+      base: "main",
+      draft: false
+    })).rejects.toThrow("Failed to create pull request: Branch not found");
+  });
+});

package/src/tools/github.create_pull_request.ts

@@ -1,28 +1,29 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { CreatePullRequestInputSchema } from "./contract.js";
 
-export const CreatePullRequestInputSchema = z.object({
-  title: z.string(),
-  body: z.string(),
-  head: z.string(),
-  base: z.string().optional().default("main"),
-  draft: z.boolean().optional().default(false),
-});
+export { CreatePullRequestInputSchema };
+
+export async function createPullRequestHandler(args: z.input<typeof CreatePullRequestInputSchema>) {
+  const params = CreatePullRequestInputSchema.parse(args);
 
-export async function createPullRequestHandler(args: z.infer<typeof CreatePullRequestInputSchema>) {
   const tdArgs = [
     "gh",
     "create-pr",
-    "--title", args.title,
-    "--body", args.body,
-    "--head", args.head,
-    "--base", args.base
+    "--title", params.title,
+    "--body", params.body,
+    "--head", params.head,
+    "--base", params.base
   ];
 
-  if (args.draft) {
+  if (params.draft) {
     tdArgs.push("--draft");
   }
 
+  if (params.repo) {
+    tdArgs.push("--repo", params.repo);
+  }
+
   const result = await runCommand("td-cli", tdArgs);
 
   if (result.exitCode !== 0) {

package/src/tools/jules/shared.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from "vitest";
+import { parseJulesSession } from "./shared.js";
+
+describe("jules/shared", () => {
+  describe("parseJulesSession", () => {
+    it("should strip 'sessions/' prefix from session name to form ID", () => {
+      const input = {
+        name: "sessions/12345",
+        state: "IN_PROGRESS",
+      };
+      const result = parseJulesSession(input);
+      expect(result.id).toBe("12345");
+      expect(result.status).toBe("IN_PROGRESS");
+    });
+
+    it("should use raw name as ID if 'sessions/' prefix is absent", () => {
+      const input = {
+        name: "custom-session-id",
+        state: "SUCCEEDED",
+      };
+      expect(parseJulesSession(input).id).toBe("custom-session-id");
+    });
+
+    it("should default name/id to empty string if missing", () => {
+      expect(parseJulesSession({}).id).toBe("");
+    });
+
+    it("should map states to COMPLETED, FAILED, IN_PROGRESS, or fallback PENDING", () => {
+      expect(parseJulesSession({ state: "SUCCEEDED" }).status).toBe("COMPLETED");
+      expect(parseJulesSession({ state: "COMPLETED" }).status).toBe("COMPLETED");
+
+      expect(parseJulesSession({ state: "FAILED" }).status).toBe("FAILED");
+      expect(parseJulesSession({ state: "CANCELLED" }).status).toBe("FAILED");
+      expect(parseJulesSession({ state: "TERMINATED" }).status).toBe("FAILED");
+
+      expect(parseJulesSession({ state: "IN_PROGRESS" }).status).toBe("IN_PROGRESS");
+
+      expect(parseJulesSession({ state: "UNKNOWN_STATE" }).status).toBe("PENDING");
+      expect(parseJulesSession({}).status).toBe("PENDING");
+    });
+
+    it("should extract pullRequestUrl from outputs array when present", () => {
+      const input = {
+        name: "sessions/abc",
+        outputs: [
+          { type: "text", text: "logs" },
+          { pullRequest: { url: "https://github.com/arii/boomtick/pull/100" } },
+        ],
+      };
+      const session = parseJulesSession(input);
+      expect(session.pullRequestUrl).toBe("https://github.com/arii/boomtick/pull/100");
+    });
+
+    it("should return undefined pullRequestUrl if missing or invalid outputs", () => {
+      expect(parseJulesSession({ outputs: [] }).pullRequestUrl).toBeUndefined();
+      expect(parseJulesSession({ outputs: [{ other: "data" }] }).pullRequestUrl).toBeUndefined();
+      expect(parseJulesSession({ outputs: "not-an-array" }).pullRequestUrl).toBeUndefined();
+    });
+
+    it("should parse createTime or fallback to current date", () => {
+      const timeStr = "2025-01-01T12:00:00Z";
+      const sessionWithTime = parseJulesSession({ createTime: timeStr });
+      expect(sessionWithTime.createdAt).toEqual(new Date(timeStr));
+
+      const sessionWithoutTime = parseJulesSession({});
+      expect(sessionWithoutTime.createdAt).toBeInstanceOf(Date);
+    });
+  });
+});

package/src/tools/repo.get_package_scripts.test.ts

@@ -30,6 +30,12 @@ describe("repo.get_package_scripts", () => {
     await expect(getPackageScriptsHandler({})).rejects.toThrow("Failed to read package.json: File not found");
   });
 
+  it("should throw error when package.json is malformed", async () => {
+    vi.mocked(fs.readFile).mockResolvedValue("{ invalid json ");
+
+    await expect(getPackageScriptsHandler({})).rejects.toThrow(/Failed to read package.json: Malformed package.json:/);
+  });
+
   it("should filter scripts by pattern", async () => {
     const mockPkg = {
       scripts: {