@arii/boomtick-mcp 0.4.0 → 0.4.2

package/src/config.ts

@@ -1,4 +1,3 @@
-import dotenv from "dotenv";
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
@@ -6,10 +5,14 @@ import { execSync } from "child_process";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-dotenv.config({
-  path: path.resolve(__dirname, "../.env"),
-  quiet: true
-});
+const envPath = path.resolve(__dirname, "../.env");
+if (fs.existsSync(envPath) && typeof process.loadEnvFile === "function") {
+  try {
+    process.loadEnvFile(envPath);
+  } catch {
+    // Ignore if already loaded or invalid
+  }
+}
 
 function getGithubToken(): string | undefined {
   if (process.env.GITHUB_TOKEN) {
@@ -36,9 +39,11 @@ export function initializeConfig() {
   }
 
   try {
-    // Attempt to load core properties from the Python CLI to avoid duplication
+    // Attempt to load core properties from the Python CLI in the active workspace
+    const cwd = process.env.BOOMTICK_REPO_PATH || process.cwd();
     const cmd = `td-cli config view`;
     const output = execSync(cmd, {
+      cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -64,10 +69,27 @@ function findRepoRoot() {
     return process.env.BOOMTICK_REPO_PATH;
   }
 
-  // Traverse up to find workspace.json or .git
-  let current = __dirname;
+  // Traverse up from process.cwd() to find project_config.json, workspace.json, or .git
+  let current = process.cwd();
   while (current !== path.parse(current).root) {
-    if (fs.existsSync(path.join(current, "workspace.json")) || fs.existsSync(path.join(current, ".git"))) {
+    if (
+      fs.existsSync(path.join(current, "project_config.json")) ||
+      fs.existsSync(path.join(current, "workspace.json")) ||
+      fs.existsSync(path.join(current, ".git"))
+    ) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+
+  // Fallback to __dirname search if discovery from cwd fails
+  current = __dirname;
+  while (current !== path.parse(current).root) {
+    if (
+      fs.existsSync(path.join(current, "project_config.json")) ||
+      fs.existsSync(path.join(current, "workspace.json")) ||
+      fs.existsSync(path.join(current, ".git"))
+    ) {
       return current;
     }
     current = path.dirname(current);
@@ -79,20 +101,28 @@ function findRepoRoot() {
 export const config = {
   get githubToken() { return getGithubToken(); },
   get githubOwner() {
-    if (process.env.GITHUB_OWNER) return process.env.GITHUB_OWNER;
     const repoString = cachedDynamicConfig?.github_repo;
-    if (typeof repoString !== "string" || !repoString.includes("/")) {
-      throw new Error("GITHUB_OWNER must be set via environment variable or project_config.json");
+    if (typeof repoString === "string" && repoString.includes("/")) {
+      return repoString.split("/")[0];
+    }
+    if (process.env.GITHUB_OWNER) return process.env.GITHUB_OWNER;
+    const envRepo = process.env.GITHUB_REPOSITORY || process.env.GH_REPO;
+    if (envRepo && envRepo.includes("/")) {
+      return envRepo.split("/")[0];
     }
-    return repoString.split("/")[0];
+    throw new Error("GITHUB_OWNER must be set via environment variable or project_config.json");
   },
   get githubRepo() {
-    if (process.env.GITHUB_REPO) return process.env.GITHUB_REPO;
     const repoString = cachedDynamicConfig?.github_repo;
-    if (typeof repoString !== "string" || !repoString.includes("/")) {
-      throw new Error("GITHUB_REPO must be set via environment variable or project_config.json");
+    if (typeof repoString === "string" && repoString.includes("/")) {
+      return repoString.split("/")[1];
+    }
+    if (process.env.GITHUB_REPO) return process.env.GITHUB_REPO;
+    const envRepo = process.env.GITHUB_REPOSITORY || process.env.GH_REPO;
+    if (envRepo && envRepo.includes("/")) {
+      return envRepo.split("/")[1];
     }
-    return repoString.split("/")[1];
+    throw new Error("GITHUB_REPO must be set via environment variable or project_config.json");
   },
   get repoPath() {
     return findRepoRoot();

package/src/lib/git.ts

@@ -2,6 +2,40 @@ import { runCommand } from "./shell.js";
 import { config } from "../config.js";
 import path from "path";
 import fs from "fs/promises";
+import { execSync } from "child_process";
+
+const repoCache = new Map<string, string>();
+
+export function resolveRepo(explicitRepo?: string | null, cwd?: string): string {
+  if (explicitRepo && explicitRepo.trim().length > 0) {
+    return explicitRepo.trim();
+  }
+
+  const targetCwd = cwd || process.cwd();
+  if (repoCache.has(targetCwd)) {
+    return repoCache.get(targetCwd)!;
+  }
+
+  try {
+    const url = execSync("git remote get-url origin", {
+      cwd: targetCwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+
+    const match = url.match(/[:/]([^/]+\/[^/.]+)(\.git)?$/);
+    if (match) {
+      repoCache.set(targetCwd, match[1]);
+      return match[1];
+    }
+  } catch (e) {
+    // Ignore error and fall back to static config
+  }
+
+  const fallback = `${config.githubOwner}/${config.githubRepo}`;
+  repoCache.set(targetCwd, fallback);
+  return fallback;
+}
 
 function validatePrNumber(value: unknown): number {
   const prNumber = Number(value);

package/src/lib/param_utils.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from "vitest";
+import { normalizeArguments } from "./param_utils.js";
+
+describe("param_utils.normalizeArguments", () => {
+  it("should convert snake_case keys to camelCase", () => {
+    const input = {
+      pr_number: 123,
+      issue_number: 456,
+      worktree_path: "/tmp/worktree",
+      base_branch: "main",
+    };
+    const output = normalizeArguments(input);
+    expect(output).toEqual({
+      prNumber: 123,
+      issueNumber: 456,
+      worktreePath: "/tmp/worktree",
+      baseBranch: "main",
+    });
+  });
+
+  it("should coerce numeric strings for prNumber and issueNumber", () => {
+    const input = {
+      pr_number: "789",
+      issue_number: "101",
+    };
+    const output = normalizeArguments(input);
+    expect(output).toEqual({
+      prNumber: 789,
+      issueNumber: 101,
+    });
+  });
+
+  it("should synchronize branch and branchName", () => {
+    expect(normalizeArguments({ branch: "feat-x" })).toEqual({
+      branch: "feat-x",
+      branchName: "feat-x",
+    });
+
+    expect(normalizeArguments({ branch_name: "feat-y" })).toEqual({
+      branchName: "feat-y",
+      branch: "feat-y",
+    });
+  });
+
+  it("should handle null or empty arguments safely", () => {
+    expect(normalizeArguments(null)).toEqual({});
+    expect(normalizeArguments(undefined)).toEqual({});
+  });
+});

package/src/lib/param_utils.ts

@@ -0,0 +1,42 @@
+export function normalizeArguments(args: Record<string, unknown> | null | undefined): Record<string, unknown> {
+  if (!args || typeof args !== "object") {
+    return {};
+  }
+
+  const result: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(args)) {
+    // Convert snake_case to camelCase
+    const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+
+    // Normalize value recursively if it's an object/array
+    let normalizedValue = value;
+    if (Array.isArray(value)) {
+      normalizedValue = value.map((item) =>
+        item && typeof item === "object" ? normalizeArguments(item as Record<string, unknown>) : item
+      );
+    } else if (value && typeof value === "object" && !(value instanceof RegExp)) {
+      normalizedValue = normalizeArguments(value as Record<string, unknown>);
+    }
+
+    // Coerce numeric string to integer for prNumber / issueNumber if applicable
+    if ((camelKey === "prNumber" || camelKey === "issueNumber") && typeof normalizedValue === "string") {
+      const parsedNum = parseInt(normalizedValue, 10);
+      if (!isNaN(parsedNum)) {
+        normalizedValue = parsedNum;
+      }
+    }
+
+    result[camelKey] = normalizedValue;
+  }
+
+  // Parameter aliases harmonization
+  // branch vs branchName harmonization
+  if (result.branch !== undefined && result.branchName === undefined) {
+    result.branchName = result.branch;
+  } else if (result.branchName !== undefined && result.branch === undefined) {
+    result.branch = result.branchName;
+  }
+
+  return result;
+}

package/src/mcp/definitions.ts

@@ -99,7 +99,7 @@ export const MCP_RESOURCES: Resource[] = [
   },
 ];
 
-export const MCP_TOOLS: Tool[] = [
+const BASE_MCP_TOOLS: Tool[] = [
   {
     name: "boomtick.health",
     description: "Check the health and configuration of the MCP server.",
@@ -276,3 +276,14 @@ export const MCP_TOOLS: Tool[] = [
     inputSchema: SearchDdgsInputJsonSchema as any,
   },
 ];
+
+export const MCP_TOOLS: Tool[] = BASE_MCP_TOOLS.flatMap((tool) => {
+  const underscoreName = tool.name.replace(/\./g, "_");
+  if (underscoreName !== tool.name) {
+    return [
+      { ...tool, name: underscoreName },
+      tool,
+    ];
+  }
+  return [tool];
+});

package/src/mcp/schemas.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+
+describe("MCP tool schemas export", () => {
+  it("should generate valid schema files with non-null parameters object", () => {
+    const schemasDir = path.resolve(process.cwd(), ".mcp/schemas");
+    if (!fs.existsSync(schemasDir)) {
+      execSync("npx tsx scripts/sync-mcp-schemas.ts", { cwd: process.cwd() });
+    }
+    expect(fs.existsSync(schemasDir)).toBe(true);
+
+    const files = fs.readdirSync(schemasDir).filter((f) => f.endsWith(".json"));
+    expect(files.length).toBeGreaterThan(0);
+
+    for (const file of files) {
+      const filePath = path.join(schemasDir, file);
+      const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+
+      expect(content).toHaveProperty("name");
+      expect(typeof content.name).toBe("string");
+
+      expect(content).toHaveProperty("description");
+      expect(typeof content.description).toBe("string");
+
+      expect(content).toHaveProperty("parameters");
+      expect(content.parameters).not.toBeNull();
+      expect(typeof content.parameters).toBe("object");
+      expect(content.parameters.type).toBe("object");
+      expect(content.parameters.properties).toBeDefined();
+    }
+  });
+});

package/src/mcp/server.ts

@@ -11,6 +11,7 @@ import {
 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";
@@ -182,80 +183,114 @@ 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 as Record<string, unknown>);
+
+        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 || {})));
+            return createSuccessResult(await getPackageScriptsHandler(GetPackageScriptsInputSchema.parse(normArgs)));
+          case "repo.get.route.map":
           case "repo.get_route_map":
-            return createSuccessResult(await getRouteMapHandler(GetRouteMapInputSchema.parse(request.params.arguments || {})));
+            return createSuccessResult(await getRouteMapHandler(GetRouteMapInputSchema.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 || {})));
+            return createSuccessResult(await runTestsHandler(RunTestsInputSchema.parse(normArgs)));
+          case "repo.run.lighthouse":
           case "repo.run_lighthouse":
-            return createSuccessResult(await runLighthouseHandler(RunLighthouseInputSchema.parse(request.params.arguments || {})));
+            return createSuccessResult(await runLighthouseHandler(RunLighthouseInputSchema.parse(normArgs)));
+          case "repo.run.playwright":
           case "repo.run_playwright":
-            return createSuccessResult(await runPlaywrightHandler(RunPlaywrightInputSchema.parse(request.params.arguments || {})));
+            return createSuccessResult(await runPlaywrightHandler(RunPlaywrightInputSchema.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)));
+            return createSuccessResult(await triggerJulesFeedbackHandler(TriggerJulesFeedbackInputSchema.parse(normArgs)));
+          case "agent.search.ddgs":
           case "agent.search_ddgs":
-            return createSuccessResult(await ddgsSearchHandler(DdgsSearchInputSchema.parse(request.params.arguments)));
+            return createSuccessResult(await ddgsSearchHandler(DdgsSearchInputSchema.parse(normArgs)));
           default:
             return createErrorResult(`Tool not found: ${request.params.name}`);
         }