@arii/boomtick-mcp 0.3.7 → 0.4.0

package/dist/tools/github.create_pull_request.test.js

@@ -0,0 +1,93 @@
+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/dist/tools/jules/shared.test.js

@@ -0,0 +1,58 @@
+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/dist/tools/repo.get_package_scripts.test.js

@@ -20,6 +20,10 @@ describe("repo.get_package_scripts", () => {
         vi.mocked(fs.readFile).mockRejectedValue(new Error("File not found"));
         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: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "description": "Boomtick MCP Guide: PR Rescue + Merge Conflict Agent",
   "repository": {
     "type": "git",

package/src/config.test.ts

@@ -0,0 +1,146 @@
+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/src/lib/error_utils.test.ts

@@ -0,0 +1,27 @@
+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/src/lib/result.test.ts

@@ -0,0 +1,48 @@
+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/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,
+      });
+    });
+  });
+});