@arii/boomtick-mcp 0.4.2 → 0.5.0

package/dist/tools/repo.logs.js

@@ -1,14 +1,18 @@
 import { z } from "zod";
-import { runTDCli } from "../lib/td-cli.js";
+import { runTDCli } from "./jules/shared.js";
 export const RepoLogsInputSchema = z.object({
     prNumber: z.number(),
     grep: z.string().optional(),
+    repo: z.string().optional(),
 });
 export async function repoLogsHandler(args) {
     const params = ["repo", "logs", args.prNumber.toString()];
     if (args.grep) {
         params.push("--grep", args.grep);
     }
+    if (args.repo) {
+        params.push("--repo", args.repo);
+    }
     const output = await runTDCli(params);
     return {
         logs: output.logs || (output.data ? output.data.logs : undefined)

package/dist/tools/repo.read_agent_context.js

@@ -1,6 +1,32 @@
 import { z } from "zod";
 import { config } from "../config.js";
-import { loadStandaloneAgentContext } from "../lib/td-cli.js";
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+export const loadStandaloneAgentContext = (repoRoot = process.cwd()) => {
+    const configPath = path.join(repoRoot, "project_config.json");
+    let projectConfig = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            projectConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        }
+        catch (e) {
+            console.warn(`[MCP Warning] Failed to parse ${configPath}:`, e);
+        }
+    }
+    let gitCommit = "unknown";
+    try {
+        gitCommit = execSync("git rev-parse HEAD", { cwd: repoRoot, encoding: "utf-8" }).trim();
+    }
+    catch {
+        // Fallback if git is unavailable
+    }
+    return {
+        packageName: projectConfig.packageName ?? "boomtick",
+        gitCommit,
+        config: projectConfig,
+    };
+};
 export const ReadAgentContextInputSchema = z.object({});
 export async function readAgentContextHandler(_args) {
     const context = loadStandaloneAgentContext(config.repoPath);

package/dist/tools/repo.read_agent_context.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { loadStandaloneAgentContext } from "../lib/td-cli.js";
+import { loadStandaloneAgentContext } from "./repo.read_agent_context.js";
 describe("Standalone Agent Context Loader", () => {
     it("should load agent context without submodule references", () => {
         const context = loadStandaloneAgentContext(process.cwd());

package/dist/tools/repo.read_ci_logs.js

@@ -1,14 +1,18 @@
 import { z } from "zod";
-import { runTDCli } from "../lib/td-cli.js";
+import { runTDCli } from "./jules/shared.js";
 export const ReadCiLogsInputSchema = z.object({
     prNumber: z.number(),
     all: z.boolean().optional(),
+    repo: z.string().optional(),
 });
 export async function readCiLogsHandler(args) {
     const params = ["repo", "ci-logs", args.prNumber.toString()];
     if (args.all) {
         params.push("--all");
     }
+    if (args.repo) {
+        params.push("--repo", args.repo);
+    }
     const output = await runTDCli(params);
     return {
         checks: output.checks,

package/dist/tools/repo.run_tests.js

@@ -5,7 +5,7 @@ export const RunTestsInputSchema = z.object({
     timeoutSeconds: z.number().optional().default(300),
     worktreePath: z.string().optional(),
 });
-export function parseCommandArguments(fullCmd) {
+function parseCommandArguments(fullCmd) {
     const tokens = [];
     const regex = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g;
     let match;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Boomtick MCP Guide: PR Rescue + Merge Conflict Agent",
   "repository": {
     "type": "git",
@@ -17,7 +17,6 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.0",
-    "dotenv": "^17.4.2",
     "zod": "^4.4.3"
   },
   "engines": {
@@ -27,14 +26,12 @@
   "devDependencies": {
     "@types/node": "^20.17.15",
     "json-schema-to-zod": "^2.8.1",
-    "shx": "^0.4.0",
     "tsx": "^4.22.4",
     "typescript": "^5.7.3",
-    "vitest": "^4.1.9",
-    "yaml": "^2.9.0"
+    "vitest": "^4.1.9"
   },
   "scripts": {
-    "build": "tsx scripts/sync-contracts.ts && tsc && shx cp src/tools/ddgs_search.py dist/tools/ && tsx scripts/sync-mcp-schemas.ts",
+    "build": "tsx scripts/sync-contracts.ts && tsc && tsx scripts/sync-mcp-schemas.ts",
     "watch": "tsc -w",
     "start": "node dist/index.js",
     "test": "tsx scripts/sync-contracts.ts && tsx scripts/sync-mcp-schemas.ts && vitest run",

package/src/agents/verifier-agent.prompt.md

@@ -10,10 +10,6 @@ Required:
 - test
 - build
 
-Conditional:
-- Playwright for UI/routes/browser behavior
-- Lighthouse for performance/accessibility/SEO-sensitive changes
-
 Output:
 - commands run
 - pass/fail status

package/src/lib/git.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { getChangedFiles, getMergeConflictFiles } from "./git.js";
+import * as shell from "./shell.js";
+
+vi.mock("./shell.js", () => ({
+  runCommand: vi.fn(),
+}));
+
+describe("Git Helpers", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("getChangedFiles", () => {
+    it("should parse null-delimited git diff output correctly", async () => {
+      // Mock git diff output with null character delimiters:
+      // Status M -> file1.txt
+      // Status A -> file2.txt
+      // Status R100 -> old.txt -> new.txt
+      const mockStdout = "M\0file1.txt\0A\0file2.txt\0R100\0old.txt\0new.txt\0";
+      vi.mocked(shell.runCommand).mockResolvedValueOnce({
+        exitCode: 0,
+        stdout: mockStdout,
+        stderr: "",
+        durationMs: 10,
+        command: "git diff --name-status -z main...HEAD",
+      });
+
+      const result = await getChangedFiles("main", "HEAD");
+
+      expect(shell.runCommand).toHaveBeenCalledWith(
+        "git",
+        ["diff", "--name-status", "-z", "main...HEAD"],
+        { cwd: undefined }
+      );
+      expect(result).toEqual([
+        { status: "M", path: "file1.txt" },
+        { status: "A", path: "file2.txt" },
+        { status: "R100", path: "new.txt", oldPath: "old.txt" },
+      ]);
+    });
+
+    it("should throw error if git diff fails", async () => {
+      vi.mocked(shell.runCommand).mockResolvedValueOnce({
+        exitCode: 1,
+        stdout: "",
+        stderr: "fatal: bad revision",
+        durationMs: 10,
+        command: "git diff --name-status -z invalid...HEAD",
+      });
+
+      await expect(getChangedFiles("invalid", "HEAD")).rejects.toThrow(
+        "Failed to get changed files: fatal: bad revision"
+      );
+    });
+  });
+
+  describe("getMergeConflictFiles", () => {
+    it("should parse git merge-tree output when conflicts exist", async () => {
+      // Output with 40-char tree hash followed by conflicting filenames
+      const mockStdout =
+        "5d71843ed2e051b2be91361db7bea0fc4ee1e5a0\nfile1.txt\nsrc/file2.ts\n";
+      vi.mocked(shell.runCommand).mockResolvedValueOnce({
+        exitCode: 1, // merge-tree exits 1 on conflicts
+        stdout: mockStdout,
+        stderr: "",
+        durationMs: 10,
+        command: "git merge-tree --write-tree --name-only main feature",
+      });
+
+      const conflicts = await getMergeConflictFiles("main", "feature");
+
+      expect(shell.runCommand).toHaveBeenCalledWith(
+        "git",
+        ["merge-tree", "--write-tree", "--name-only", "main", "feature"],
+        { cwd: undefined }
+      );
+      expect(conflicts).toEqual(["file1.txt", "src/file2.ts"]);
+    });
+
+    it("should return empty array when no conflicts exist", async () => {
+      const mockStdout = "5d71843ed2e051b2be91361db7bea0fc4ee1e5a0\n";
+      vi.mocked(shell.runCommand).mockResolvedValueOnce({
+        exitCode: 0,
+        stdout: mockStdout,
+        stderr: "",
+        durationMs: 10,
+        command: "git merge-tree --write-tree --name-only main feature",
+      });
+
+      const conflicts = await getMergeConflictFiles("main", "feature");
+
+      expect(conflicts).toEqual([]);
+    });
+
+    it("should throw error if git merge-tree exits with unexpected exit code", async () => {
+      vi.mocked(shell.runCommand).mockResolvedValueOnce({
+        exitCode: 128,
+        stdout: "",
+        stderr: "fatal: not a valid object name",
+        durationMs: 10,
+        command: "git merge-tree --write-tree --name-only invalid feature",
+      });
+
+      await expect(getMergeConflictFiles("invalid", "feature")).rejects.toThrow(
+        "Git merge-tree failed: fatal: not a valid object name"
+      );
+    });
+  });
+});

package/src/lib/git.ts

@@ -73,3 +73,78 @@ export async function removeWorktree(worktreePath: string): Promise<void> {
   await runCommand("git", ["worktree", "remove", "--force", worktreePath]);
   await runCommand("git", ["worktree", "prune"]);
 }
+
+export interface ChangedFile {
+  status: string;
+  path: string;
+  oldPath?: string;
+}
+
+export async function getChangedFiles(
+  base: string = "main",
+  head: string = "HEAD",
+  cwd?: string
+): Promise<ChangedFile[]> {
+  const result = await runCommand(
+    "git",
+    ["diff", "--name-status", "-z", `${base}...${head}`],
+    { cwd }
+  );
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to get changed files: ${result.stderr}`);
+  }
+
+  const tokens = result.stdout.split("\0").filter((t) => t.length > 0);
+  const files: ChangedFile[] = [];
+
+  let i = 0;
+  while (i < tokens.length) {
+    const status = tokens[i];
+    if (status.startsWith("R") || status.startsWith("C")) {
+      const oldPath = tokens[i + 1];
+      const newPath = tokens[i + 2];
+      if (oldPath && newPath) {
+        files.push({ status, path: newPath, oldPath });
+      }
+      i += 3;
+    } else {
+      const filePath = tokens[i + 1];
+      if (filePath) {
+        files.push({ status, path: filePath });
+      }
+      i += 2;
+    }
+  }
+
+  return files;
+}
+
+export async function getMergeConflictFiles(
+  baseBranch: string = "main",
+  headRef: string = "HEAD",
+  cwd?: string
+): Promise<string[]> {
+  const result = await runCommand(
+    "git",
+    ["merge-tree", "--write-tree", "--name-only", baseBranch, headRef],
+    { cwd }
+  );
+
+  // git merge-tree returns exit code 1 if conflicts are present, 0 if clean merge
+  if (result.exitCode !== 0 && result.exitCode !== 1) {
+    throw new Error(`Git merge-tree failed: ${result.stderr}`);
+  }
+
+  const lines = result.stdout
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0);
+
+  // First line is tree hash if successful or conflict output
+  // When conflicts exist, git merge-tree --write-tree --name-only outputs conflicted filenames
+  // Skip tree hash line if present (40 hex chars)
+  const files = lines.filter((line) => !/^[0-9a-f]{40}$/i.test(line));
+
+  return files;
+}

package/src/mcp/definitions.ts

@@ -7,14 +7,11 @@ import {
   GetMergeConflictFilesInputJsonSchema,
   GetChangedFilesInputJsonSchema,
   GetPackageScriptsInputJsonSchema,
-  GetRouteMapInputJsonSchema,
   ReadCiLogsInputJsonSchema,
   RepoLogsInputJsonSchema,
   CreateBranchInputJsonSchema,
   CreateRepairBranchInputJsonSchema,
   RunTestsInputJsonSchema,
-  RunLighthouseInputJsonSchema,
-  RunPlaywrightInputJsonSchema,
   CommitPatchInputJsonSchema,
   OpenReplacementPrInputJsonSchema,
   CreatePullRequestInputJsonSchema,
@@ -30,7 +27,9 @@ import {
   JulesSessionIdInputJsonSchema,
   JulesSendMessageInputJsonSchema,
   JulesListSessionsInputJsonSchema,
-  SearchDdgsInputJsonSchema,
+  GetPrReviewsInputJsonSchema,
+  GetPrCommitsInputJsonSchema,
+  GetWorkflowRunsInputJsonSchema,
 } from "../tools/contract.js";
 
 export const MCP_PROMPTS: Prompt[] = [
@@ -67,12 +66,6 @@ export const MCP_RESOURCES: Resource[] = [
     mimeType: "application/json",
     description: "The root package.json file of the repository.",
   },
-  {
-    uri: "repo://routes",
-    name: "Route Map",
-    mimeType: "application/json",
-    description: "The mapping of application routes to content files.",
-  },
   {
     uri: "repo://design-tokens",
     name: "Design Tokens",
@@ -85,18 +78,6 @@ export const MCP_RESOURCES: Resource[] = [
     mimeType: "application/json",
     description: "The validation report for a specific repair branch.",
   },
-  {
-    uri: "repo://lighthouse/{branch}",
-    name: "Lighthouse Report",
-    mimeType: "application/json",
-    description: "Lighthouse CI report for a specific branch.",
-  },
-  {
-    uri: "repo://playwright/{branch}",
-    name: "Playwright Report",
-    mimeType: "application/json",
-    description: "Playwright test report for a specific branch.",
-  },
 ];
 
 const BASE_MCP_TOOLS: Tool[] = [
@@ -145,11 +126,6 @@ const BASE_MCP_TOOLS: Tool[] = [
     description: "Get the scripts defined in package.json.",
     inputSchema: GetPackageScriptsInputJsonSchema as any,
   },
-  {
-    name: "repo.get_route_map",
-    description: "Get the mapping of routes to content files.",
-    inputSchema: GetRouteMapInputJsonSchema as any,
-  },
   {
     name: "repo.read_ci_logs",
     description: "Read CI logs for a given pull request.",
@@ -175,16 +151,6 @@ const BASE_MCP_TOOLS: Tool[] = [
     description: "Run repository tests and checks.",
     inputSchema: RunTestsInputJsonSchema as any,
   },
-  {
-    name: "repo.run_lighthouse",
-    description: "Run Lighthouse CI audits.",
-    inputSchema: RunLighthouseInputJsonSchema as any,
-  },
-  {
-    name: "repo.run_playwright",
-    description: "Run Playwright E2E tests.",
-    inputSchema: RunPlaywrightInputJsonSchema as any,
-  },
   {
     name: "repo.commit_patch",
     description: "Commit verified repair changes in a worktree.",
@@ -210,6 +176,21 @@ const BASE_MCP_TOOLS: Tool[] = [
     description: "Get details of a GitHub PR including title, state, and URLs.",
     inputSchema: GetPrInputJsonSchema as any,
   },
+  {
+    name: "github.get_pr_reviews",
+    description: "Get top-level reviews, verdicts, states, and bodies for a GitHub PR.",
+    inputSchema: GetPrReviewsInputJsonSchema as any,
+  },
+  {
+    name: "github.get_pr_commits",
+    description: "List commits and commit metadata (SHAs, authors, messages) for a GitHub PR.",
+    inputSchema: GetPrCommitsInputJsonSchema as any,
+  },
+  {
+    name: "repo.get_workflow_runs",
+    description: "List recent GitHub Actions workflow runs for the repository.",
+    inputSchema: GetWorkflowRunsInputJsonSchema as any,
+  },
   {
     name: "github.issue_view",
     description: "View details of a GitHub issue including title, body, and state.",
@@ -270,11 +251,6 @@ const BASE_MCP_TOOLS: Tool[] = [
     description: "Automatically collect CI status/logs for the PR associated with a Jules session and send them back as feedback.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
   },
-  {
-    name: "agent.search_ddgs",
-    description: "Search the web using DuckDuckGo (via ddgs python library).",
-    inputSchema: SearchDdgsInputJsonSchema as any,
-  },
 ];
 
 export const MCP_TOOLS: Tool[] = BASE_MCP_TOOLS.flatMap((tool) => {

package/src/mcp/server.test.ts

@@ -3,11 +3,8 @@ 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", () => ({
@@ -124,19 +121,6 @@ describe("BoomtickMCPServer", () => {
       });
     });
 
-    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 = {};");
@@ -178,32 +162,6 @@ describe("BoomtickMCPServer", () => {
       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");
 

package/src/mcp/server.ts

@@ -21,14 +21,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";
@@ -48,7 +45,6 @@ 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";
@@ -129,12 +125,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");
@@ -156,20 +146,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}`);
     });
   }
@@ -213,9 +189,6 @@ export class BoomtickMCPServer {
           case "repo.get.package.scripts":
           case "repo.get_package_scripts":
             return createSuccessResult(await getPackageScriptsHandler(GetPackageScriptsInputSchema.parse(normArgs)));
-          case "repo.get.route.map":
-          case "repo.get_route_map":
-            return createSuccessResult(await getRouteMapHandler(GetRouteMapInputSchema.parse(normArgs)));
           case "repo.read.ci.logs":
           case "repo.read_ci_logs":
             return createSuccessResult(await readCiLogsHandler(ReadCiLogsInputSchema.parse(normArgs)));
@@ -230,12 +203,6 @@ export class BoomtickMCPServer {
           case "repo.run.tests":
           case "repo.run_tests":
             return createSuccessResult(await runTestsHandler(RunTestsInputSchema.parse(normArgs)));
-          case "repo.run.lighthouse":
-          case "repo.run_lighthouse":
-            return createSuccessResult(await runLighthouseHandler(RunLighthouseInputSchema.parse(normArgs)));
-          case "repo.run.playwright":
-          case "repo.run_playwright":
-            return createSuccessResult(await runPlaywrightHandler(RunPlaywrightInputSchema.parse(normArgs)));
           case "repo.commit.patch":
           case "repo.commit_patch":
             return createSuccessResult(await commitPatchHandler(CommitPatchInputSchema.parse(normArgs)));
@@ -288,9 +255,6 @@ export class BoomtickMCPServer {
           case "jules.trigger.feedback":
           case "jules.trigger_feedback":
             return createSuccessResult(await triggerJulesFeedbackHandler(TriggerJulesFeedbackInputSchema.parse(normArgs)));
-          case "agent.search.ddgs":
-          case "agent.search_ddgs":
-            return createSuccessResult(await ddgsSearchHandler(DdgsSearchInputSchema.parse(normArgs)));
           default:
             return createErrorResult(`Tool not found: ${request.params.name}`);
         }
@@ -378,15 +342,6 @@ export class BoomtickMCPServer {
       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");