@arii/boomtick-mcp 0.4.1 → 0.5.0

package/dist/mcp/server.js

@@ -4,6 +4,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSche
 import { config } from "../config.js";
 import { createSuccessResult, createErrorResult } from "../lib/result.js";
 import { MCP_TOOLS, MCP_PROMPTS, MCP_RESOURCES } from "./definitions.js";
+import { normalizeArguments } from "../lib/param_utils.js";
 import { healthHandler, HealthCheckInputSchema } from "./tools.js";
 import { searchOpenPrsHandler, SearchOpenPrsInputSchema } from "../tools/github.search_open_prs.js";
 import { getPrDiffHandler, GetPrDiffInputSchema } from "../tools/github.get_pr_diff.js";
@@ -13,14 +14,11 @@ import { getChangedFilesHandler, GetChangedFilesInputSchema } from "../tools/rep
 import { readAgentContextHandler, ReadAgentContextInputSchema } from "../tools/repo.read_agent_context.js";
 import { getCommandSchemaHandler, GetCommandSchemaInputSchema } from "../tools/repo.get_command_schema.js";
 import { getPackageScriptsHandler, GetPackageScriptsInputSchema } from "../tools/repo.get_package_scripts.js";
-import { getRouteMapHandler, GetRouteMapInputSchema } from "../tools/repo.get_route_map.js";
 import { readCiLogsHandler, ReadCiLogsInputSchema } from "../tools/repo.read_ci_logs.js";
 import { repoLogsHandler, RepoLogsInputSchema } from "../tools/repo.logs.js";
 import { createRepairBranchHandler, CreateRepairBranchInputSchema } from "../tools/repo.create_repair_branch.js";
 import { createBranchHandler, CreateBranchInputSchema } from "../tools/repo.create_branch.js";
 import { runTestsHandler, RunTestsInputSchema } from "../tools/repo.run_tests.js";
-import { runLighthouseHandler, RunLighthouseInputSchema } from "../tools/repo.run_lighthouse.js";
-import { runPlaywrightHandler, RunPlaywrightInputSchema } from "../tools/repo.run_playwright.js";
 import { commitPatchHandler, CommitPatchInputSchema } from "../tools/repo.commit_patch.js";
 import { openReplacementPrHandler, OpenReplacementPrInputSchema } from "../tools/github.open_replacement_pr.js";
 import { commentTriageSummaryHandler, CommentTriageSummaryInputSchema } from "../tools/github.comment_triage_summary.js";
@@ -38,12 +36,10 @@ import { listJulesSessionsHandler, ListJulesSessionsInputSchema } from "../tools
 import { cancelJulesSessionHandler, CancelJulesSessionInputSchema } from "../tools/jules/cancel-session.js";
 import { getJulesPullRequestHandler, GetJulesPullRequestInputSchema } from "../tools/jules/get-pr.js";
 import { triggerJulesFeedbackHandler, TriggerJulesFeedbackInputSchema } from "../tools/jules/trigger-feedback.js";
-import { ddgsSearchHandler, DdgsSearchInputSchema } from "../tools/ddgs.search.js";
 import fs from "fs/promises";
 import { existsSync, readFileSync } from "fs";
 import path from "path";
 import { spawnSync } from "child_process";
-import { fileURLToPath } from "url";
 export class BoomtickMCPServer {
     server;
     constructor() {
@@ -105,12 +101,6 @@ export class BoomtickMCPServer {
                     contents: [{ uri, mimeType: "application/json", text: content }],
                 };
             }
-            if (uri === "repo://routes") {
-                const routeMap = await getRouteMapHandler({});
-                return {
-                    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(routeMap, null, 2) }],
-                };
-            }
             if (uri === "repo://design-tokens") {
                 const tokensPath = path.join(config.repoPath, "src/styles/design-tokens.ts");
                 const content = await fs.readFile(tokensPath, "utf-8");
@@ -132,20 +122,6 @@ export class BoomtickMCPServer {
                     contents: [{ uri, mimeType: "application/json", text: JSON.stringify(logs, null, 2) }],
                 };
             }
-            if (uri.startsWith("repo://lighthouse/")) {
-                const branch = uri.split("/").pop() || "";
-                const report = await runLighthouseHandler({ route: "/", worktreePath: `../boomtick-mcp-rescue-${branch}` });
-                return {
-                    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(report, null, 2) }],
-                };
-            }
-            if (uri.startsWith("repo://playwright/")) {
-                const branch = uri.split("/").pop() || "";
-                const report = await runPlaywrightHandler({ worktreePath: `../boomtick-mcp-rescue-${branch}` });
-                return {
-                    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(report, null, 2) }],
-                };
-            }
             throw new Error(`Resource not found: ${uri}`);
         });
     }
@@ -157,77 +133,100 @@ export class BoomtickMCPServer {
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             try {
-                switch (request.params.name) {
+                const normalizedToolName = request.params.name.replace(/_/g, ".");
+                const normArgs = normalizeArguments(request.params.arguments);
+                switch (normalizedToolName) {
                     case "boomtick.health":
-                        return createSuccessResult(await healthHandler(HealthCheckInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await healthHandler(HealthCheckInputSchema.parse(normArgs)));
+                    case "github.search.open.prs":
                     case "github.search_open_prs":
-                        return createSuccessResult(await searchOpenPrsHandler(SearchOpenPrsInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await searchOpenPrsHandler(SearchOpenPrsInputSchema.parse(normArgs)));
+                    case "repo.read.agent.context":
                     case "repo.read_agent_context":
-                        return createSuccessResult(await readAgentContextHandler(ReadAgentContextInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await readAgentContextHandler(ReadAgentContextInputSchema.parse(normArgs)));
+                    case "github.get.pr.diff":
                     case "github.get_pr_diff":
-                        return createSuccessResult(await getPrDiffHandler(GetPrDiffInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getPrDiffHandler(GetPrDiffInputSchema.parse(normArgs)));
+                    case "github.get.merge.conflict.files":
                     case "github.get_merge_conflict_files":
-                        return createSuccessResult(await getMergeConflictFilesHandler(GetMergeConflictFilesInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getMergeConflictFilesHandler(GetMergeConflictFilesInputSchema.parse(normArgs)));
+                    case "github.checkout.branch":
                     case "github.checkout_branch":
-                        return createSuccessResult(await checkoutBranchHandler(CheckoutBranchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await checkoutBranchHandler(CheckoutBranchInputSchema.parse(normArgs)));
+                    case "repo.get.changed.files":
                     case "repo.get_changed_files":
-                        return createSuccessResult(await getChangedFilesHandler(GetChangedFilesInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await getChangedFilesHandler(GetChangedFilesInputSchema.parse(normArgs)));
+                    case "repo.get.command.schema":
                     case "repo.get_command_schema":
-                        return createSuccessResult(await getCommandSchemaHandler(GetCommandSchemaInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getCommandSchemaHandler(GetCommandSchemaInputSchema.parse(normArgs)));
+                    case "repo.get.package.scripts":
                     case "repo.get_package_scripts":
-                        return createSuccessResult(await getPackageScriptsHandler(GetPackageScriptsInputSchema.parse(request.params.arguments || {})));
-                    case "repo.get_route_map":
-                        return createSuccessResult(await getRouteMapHandler(GetRouteMapInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await getPackageScriptsHandler(GetPackageScriptsInputSchema.parse(normArgs)));
+                    case "repo.read.ci.logs":
                     case "repo.read_ci_logs":
-                        return createSuccessResult(await readCiLogsHandler(ReadCiLogsInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await readCiLogsHandler(ReadCiLogsInputSchema.parse(normArgs)));
                     case "repo.logs":
-                        return createSuccessResult(await repoLogsHandler(RepoLogsInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await repoLogsHandler(RepoLogsInputSchema.parse(normArgs)));
+                    case "repo.create.branch":
                     case "repo.create_branch":
-                        return createSuccessResult(await createBranchHandler(CreateBranchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createBranchHandler(CreateBranchInputSchema.parse(normArgs)));
+                    case "repo.create.repair.branch":
                     case "repo.create_repair_branch":
-                        return createSuccessResult(await createRepairBranchHandler(CreateRepairBranchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createRepairBranchHandler(CreateRepairBranchInputSchema.parse(normArgs)));
+                    case "repo.run.tests":
                     case "repo.run_tests":
-                        return createSuccessResult(await runTestsHandler(RunTestsInputSchema.parse(request.params.arguments || {})));
-                    case "repo.run_lighthouse":
-                        return createSuccessResult(await runLighthouseHandler(RunLighthouseInputSchema.parse(request.params.arguments || {})));
-                    case "repo.run_playwright":
-                        return createSuccessResult(await runPlaywrightHandler(RunPlaywrightInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await runTestsHandler(RunTestsInputSchema.parse(normArgs)));
+                    case "repo.commit.patch":
                     case "repo.commit_patch":
-                        return createSuccessResult(await commitPatchHandler(CommitPatchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await commitPatchHandler(CommitPatchInputSchema.parse(normArgs)));
+                    case "github.open.replacement.pr":
                     case "github.open_replacement_pr":
-                        return createSuccessResult(await openReplacementPrHandler(OpenReplacementPrInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await openReplacementPrHandler(OpenReplacementPrInputSchema.parse(normArgs)));
+                    case "github.comment.triage.summary":
                     case "github.comment_triage_summary":
-                        return createSuccessResult(await commentTriageSummaryHandler(CommentTriageSummaryInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await commentTriageSummaryHandler(CommentTriageSummaryInputSchema.parse(normArgs)));
+                    case "github.create.pull.request":
                     case "github.create_pull_request":
-                        return createSuccessResult(await createPullRequestHandler(CreatePullRequestInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createPullRequestHandler(CreatePullRequestInputSchema.parse(normArgs)));
+                    case "github.get.pr":
                     case "github.get_pr":
-                        return createSuccessResult(await getPrHandler(GetPrInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getPrHandler(GetPrInputSchema.parse(normArgs)));
+                    case "github.issue.view":
                     case "github.issue_view":
-                        return createSuccessResult(await issueViewHandler(IssueViewInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await issueViewHandler(IssueViewInputSchema.parse(normArgs)));
+                    case "github.issue.update":
                     case "github.issue_update":
-                        return createSuccessResult(await issueUpdateHandler(IssueUpdateInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await issueUpdateHandler(IssueUpdateInputSchema.parse(normArgs)));
+                    case "github.issue.comment":
                     case "github.issue_comment":
-                        return createSuccessResult(await issueCommentHandler(IssueCommentInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await issueCommentHandler(IssueCommentInputSchema.parse(normArgs)));
+                    case "github.create.issue":
                     case "github.create_issue":
-                        return createSuccessResult(await createIssueHandler(CreateIssueInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createIssueHandler(CreateIssueInputSchema.parse(normArgs)));
+                    case "jules.create.session":
                     case "jules.create_session":
-                        return createSuccessResult(await createJulesSessionHandler(CreateJulesSessionInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createJulesSessionHandler(CreateJulesSessionInputSchema.parse(normArgs)));
+                    case "jules.get.session":
                     case "jules.get_session":
-                        return createSuccessResult(await getJulesSessionHandler(GetJulesSessionInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getJulesSessionHandler(GetJulesSessionInputSchema.parse(normArgs)));
+                    case "jules.send.message":
                     case "jules.send_message":
-                        return createSuccessResult(await sendJulesMessageHandler(SendJulesMessageInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await sendJulesMessageHandler(SendJulesMessageInputSchema.parse(normArgs)));
+                    case "jules.get.messages":
                     case "jules.get_messages":
-                        return createSuccessResult(await getJulesMessagesHandler(GetJulesMessagesInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getJulesMessagesHandler(GetJulesMessagesInputSchema.parse(normArgs)));
+                    case "jules.list.sessions":
                     case "jules.list_sessions":
-                        return createSuccessResult(await listJulesSessionsHandler(ListJulesSessionsInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await listJulesSessionsHandler(ListJulesSessionsInputSchema.parse(normArgs)));
+                    case "jules.cancel.session":
                     case "jules.cancel_session":
-                        return createSuccessResult(await cancelJulesSessionHandler(CancelJulesSessionInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await cancelJulesSessionHandler(CancelJulesSessionInputSchema.parse(normArgs)));
+                    case "jules.get.pr":
                     case "jules.get_pr":
-                        return createSuccessResult(await getJulesPullRequestHandler(GetJulesPullRequestInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getJulesPullRequestHandler(GetJulesPullRequestInputSchema.parse(normArgs)));
+                    case "jules.trigger.feedback":
                     case "jules.trigger_feedback":
-                        return createSuccessResult(await triggerJulesFeedbackHandler(TriggerJulesFeedbackInputSchema.parse(request.params.arguments)));
-                    case "agent.search_ddgs":
-                        return createSuccessResult(await ddgsSearchHandler(DdgsSearchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await triggerJulesFeedbackHandler(TriggerJulesFeedbackInputSchema.parse(normArgs)));
                     default:
                         return createErrorResult(`Tool not found: ${request.params.name}`);
                 }
@@ -301,15 +300,6 @@ export class BoomtickMCPServer {
             console.error("❌ Fatal: td-cli pre-flight check failed:", error instanceof Error ? error.message : String(error));
             process.exit(1);
         }
-        const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const ddgsScriptPath = path.join(__dirname, "..", "tools", "ddgs_search.py");
-        try {
-            await fs.access(ddgsScriptPath);
-        }
-        catch (err) {
-            console.error(`❌ Fatal: ddgs_search.py not found at ${ddgsScriptPath}`);
-            process.exit(1);
-        }
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         console.error("Boomtick MCP Server running on stdio");

package/dist/mcp/server.test.js

@@ -2,11 +2,8 @@ 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: {
@@ -99,16 +96,6 @@ describe("BoomtickMCPServer", () => {
                 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 = {};");
@@ -141,26 +128,6 @@ describe("BoomtickMCPServer", () => {
             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({