@arii/boomtick-mcp 0.4.2 → 0.5.0

package/src/tools/ddgs.search.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ddgsSearchHandler } from "./ddgs.search.js";
-import { runCommand } from "../lib/shell.js";
-
-vi.mock("../lib/shell.js");
-
-describe("ddgsSearchHandler", () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  it("should parse arguments, sanitize query, and return search results", async () => {
-    const mockOutput = JSON.stringify([
-      { title: "Result 1", href: "https://example.com/1", body: "Description 1" },
-      { title: "Result 2", href: "https://example.com/2", body: "Description 2" },
-    ]);
-
-    vi.mocked(runCommand).mockResolvedValue({
-      stdout: mockOutput,
-      stderr: "",
-      exitCode: 0,
-      durationMs: 100,
-      command: "mock python3",
-    });
-
-    const result = await ddgsSearchHandler({ query: "test\nquery\x00", maxResults: 2 });
-
-    expect(runCommand).toHaveBeenCalledTimes(1);
-    expect(runCommand).toHaveBeenCalledWith(
-      "python3",
-      [expect.stringContaining("ddgs_search.py"), "test query", "2"]
-    );
-    expect(result.results).toHaveLength(2);
-    expect(result.results[0].title).toBe("Result 1");
-  });
-
-  it("should handle raw error when python script exits with non-zero code and non-JSON output", async () => {
-    vi.mocked(runCommand).mockResolvedValue({
-      stdout: "",
-      stderr: "Python script failed",
-      exitCode: 1,
-      durationMs: 100,
-      command: "mock python3",
-    });
-
-    await expect(ddgsSearchHandler({ query: "test query", maxResults: 2 })).rejects.toThrow(
-      "Failed to search ddgs: Python script failed"
-    );
-  });
-
-  it("should handle parsed JSON error when python script exits with non-zero code", async () => {
-    vi.mocked(runCommand).mockResolvedValue({
-      stdout: "",
-      stderr: JSON.stringify({ error: "Structured JSON error" }),
-      exitCode: 1,
-      durationMs: 100,
-      command: "mock python3",
-    });
-
-    await expect(ddgsSearchHandler({ query: "test query", maxResults: 2 })).rejects.toThrow(
-      "Failed to search ddgs: Structured JSON error"
-    );
-  });
-
-  it("should handle error when python output is not an array", async () => {
-    vi.mocked(runCommand).mockResolvedValue({
-      stdout: JSON.stringify({ error: "Something went wrong" }),
-      stderr: "",
-      exitCode: 0,
-      durationMs: 100,
-      command: "mock python3",
-    });
-
-    await expect(ddgsSearchHandler({ query: "test query", maxResults: 2 })).rejects.toThrow(
-      "Expected an array of search results"
-    );
-  });
-
-  it("should handle error when python output cannot be parsed", async () => {
-    vi.mocked(runCommand).mockResolvedValue({
-      stdout: "invalid json",
-      stderr: "",
-      exitCode: 0,
-      durationMs: 100,
-      command: "mock python3",
-    });
-
-    await expect(ddgsSearchHandler({ query: "test query", maxResults: 2 })).rejects.toThrow(
-      "Failed to parse ddgs search results"
-    );
-  });
-});

package/src/tools/ddgs.search.ts

@@ -1,58 +0,0 @@
-import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
-
-export const DdgsSearchInputSchema = z.object({
-  query: z.string(),
-  maxResults: z.number().optional().default(5),
-});
-
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export async function ddgsSearchHandler(args: z.infer<typeof DdgsSearchInputSchema>) {
-  const scriptPath = path.join(__dirname, "ddgs_search.py");
-
-  // Sanitize query by removing control characters, newlines, and null bytes
-  // eslint-disable-next-line no-control-regex
-  const safeQuery = args.query.replace(/[\x00-\x1F\x7F-\x9F]/g, " ").trim();
-  if (!safeQuery) {
-    throw new Error("Query cannot be empty after sanitization.");
-  }
-
-  const result = await runCommand("python3", [scriptPath, safeQuery, (args.maxResults ?? 5).toString()]);
-
-  // duckduckgo_search logs annoying deprecation warnings to stderr we want to ignore
-  // if it really failed, exitCode will be non-zero and we'll have stdout/stderr
-  if (result.exitCode !== 0) {
-    let parsedError = result.stderr || result.stdout;
-
-    const lines = parsedError.split("\n");
-    for (const line of lines) {
-      try {
-        const json = JSON.parse(line);
-        if (json.error) {
-          parsedError = json.error;
-          break;
-        }
-      } catch {
-        // continue
-      }
-    }
-
-    throw new Error(`Failed to search ddgs: ${parsedError}`);
-  }
-
-  try {
-    const data = JSON.parse(result.stdout);
-    if (!Array.isArray(data)) {
-      throw new Error("Expected an array of search results");
-    }
-    return { results: data };
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    throw new Error(`Failed to parse ddgs search results. Error: ${message}. Output was: ${result.stdout}`);
-  }
-}

package/src/tools/ddgs_search.py

@@ -1,23 +0,0 @@
-# pylint: disable=line-too-long
-"""DuckDuckGo Search tool."""
-import json
-import sys
-
-try:
-    from duckduckgo_search import DDGS
-except ImportError:
-    print(json.dumps({"error": "duckduckgo_search package not found. Please install it using 'pip install duckduckgo-search' (preferably in a virtual environment)."}), file=sys.stderr)
-    sys.exit(1)
-
-if len(sys.argv) != 3:
-    print(json.dumps({"error": f"Invalid argument count. Expected 2 (query, max_results), got {len(sys.argv) - 1}."}), file=sys.stderr)
-    sys.exit(1)
-
-try:
-    query = sys.argv[1]
-    max_results = int(sys.argv[2])
-    results = DDGS().text(query, max_results=max_results)
-    print(json.dumps(list(results)))
-except Exception as e:
-    print(json.dumps({"error": str(e)}), file=sys.stderr)
-    sys.exit(1)

package/src/tools/repo.get_route_map.ts

@@ -1,41 +0,0 @@
-import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
-import { config } from "../config.js";
-import path from "path";
-
-export const GetRouteMapInputSchema = z.object({
-  includeStatic: z.boolean().optional(),
-});
-
-export async function getRouteMapHandler(args: z.infer<typeof GetRouteMapInputSchema>) {
-  GetRouteMapInputSchema.parse(args);
-  // Logic based on tech-dancer repo structure: src/config/routes.ts and content/
-  const routesPath = path.join(config.repoPath, "src/config/routes.ts");
-
-  // For simplicity in MVP, we'll try to find routes by listing content files
-  // and reading the main routes file if it exists.
-  let routeMap: Record<string, string> = {};
-
-  try {
-    const gitFiles = await runCommand("git", ["ls-files", "content/"]);
-    const contentFiles = gitFiles.stdout.trim().split("\n");
-
-    for (const file of contentFiles) {
-      if (file.endsWith(".md")) {
-        const slug = path.basename(file, ".md");
-        if (file.includes("/posts/")) {
-          routeMap[`/blog/${slug}`] = file;
-        } else if (file.includes("/resources/")) {
-          routeMap[`/resources/${slug}`] = file;
-        }
-      }
-    }
-  } catch (error) {
-    // If no content files, that's fine
-  }
-
-  if (args.includeStatic) {
-    routeMap["/favicon.ico"] = "public/favicon.ico";
-  }
-  return { routeMap };
-}

package/src/tools/repo.run_lighthouse.ts

@@ -1,40 +0,0 @@
-import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
-
-export const RunLighthouseInputSchema = z.object({
-  route: z.string().optional().default("/"),
-  worktreePath: z.string().optional(),
-});
-
-export async function runLighthouseHandler(args: z.infer<typeof RunLighthouseInputSchema>) {
-  const results = await runCommand("pnpm", ["lhci", "autorun", "--json"], { cwd: args.worktreePath });
-
-  let summary = {};
-  const failures: string[] = [];
-
-  try {
-    // Attempt to parse summary from LHCI output if available
-    // For MVP, we'll provide a structured placeholder if actual JSON isn't present
-    if (results.stdout.includes("{")) {
-       const possibleJson = results.stdout.substring(results.stdout.indexOf("{"));
-       summary = JSON.parse(possibleJson);
-    } else {
-       summary = {
-         performance: 0,
-         accessibility: 0,
-         bestPractices: 0,
-         seo: 0
-       };
-    }
-  } catch (e) {
-    failures.push("Failed to parse Lighthouse report");
-  }
-
-  return {
-    success: results.exitCode === 0,
-    route: args.route,
-    summary,
-    failures,
-    command: results.command
-  };
-}

package/src/tools/repo.run_playwright.ts

@@ -1,42 +0,0 @@
-import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
-
-export const RunPlaywrightInputSchema = z.object({
-  grep: z.string().optional(),
-  worktreePath: z.string().optional(),
-  timeoutSeconds: z.number().optional().default(180),
-});
-
-export type RunPlaywrightInput = z.input<typeof RunPlaywrightInputSchema>;
-
-export async function runPlaywrightHandler(args: RunPlaywrightInput) {
-  const parsed = RunPlaywrightInputSchema.parse(args || {});
-  const tdArgs = ["repo", "run-playwright"];
-  if (parsed.grep) {
-    tdArgs.push("--grep", parsed.grep);
-  }
-  if (parsed.worktreePath) {
-    tdArgs.push("--worktree", parsed.worktreePath);
-  }
-
-  const result = await runCommand("td-cli", tdArgs, {
-    cwd: parsed.worktreePath,
-    timeout: parsed.timeoutSeconds * 1000,
-  });
-
-  if (result.exitCode !== 0) {
-    // Playwright might exit with non-zero if tests fail, but our td-cli should ideally handle it
-    // and return a JSON with success: false.
-  }
-
-  const output = JSON.parse(result.stdout);
-  if (output.status === "error") {
-     throw new Error(`Failed to run Playwright: ${output.message}`);
-  }
-
-  return {
-    success: output.success,
-    command: output.command,
-    failedTests: output.failedTests
-  };
-}