@arii/boomtick-mcp 0.3.3

package/src/tools/repo.create_branch.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createBranchHandler, CreateBranchInput } from "./repo.create_branch.js";
+import * as shell from "../lib/shell.js";
+
+vi.mock("../lib/shell.js", () => ({
+  runCommand: vi.fn(),
+}));
+
+describe("repo.create_branch", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should create a new branch from a base branch", async () => {
+    const args: CreateBranchInput = {
+      branchName: "new-feature",
+      baseBranch: "main",
+    };
+
+    (shell.runCommand as any).mockResolvedValue({ exitCode: 0, stdout: "", stderr: "" });
+
+    const result = await createBranchHandler(args);
+
+    expect(shell.runCommand).toHaveBeenCalledWith("git", ["fetch", "origin", "main"]);
+    expect(shell.runCommand).toHaveBeenCalledWith("git", ["checkout", "-b", "new-feature", "origin/main"]);
+    expect(result).toEqual({
+      success: true,
+      branchName: "new-feature",
+      baseBranch: "main",
+    });
+  });
+
+  it("should use default base branch 'main' if not provided", async () => {
+    const args: CreateBranchInput = {
+      branchName: "another-feature",
+    };
+
+    (shell.runCommand as any).mockResolvedValue({ exitCode: 0, stdout: "", stderr: "" });
+
+    const result = await createBranchHandler(args);
+
+    expect(shell.runCommand).toHaveBeenCalledWith("git", ["fetch", "origin", "main"]);
+    expect(shell.runCommand).toHaveBeenCalledWith("git", ["checkout", "-b", "another-feature", "origin/main"]);
+  });
+
+  it("should throw error if git command fails", async () => {
+    const args: CreateBranchInput = {
+      branchName: "fail-branch",
+    };
+
+    (shell.runCommand as any).mockResolvedValue({ exitCode: 1, stdout: "", stderr: "Error creating branch" });
+
+    await expect(createBranchHandler(args)).rejects.toThrow("Failed to create branch fail-branch: Error creating branch");
+  });
+});

package/src/tools/repo.create_branch.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+
+export const CreateBranchInputSchema = z.object({
+  branchName: z.string(),
+  baseBranch: z.string().optional().default("main"),
+});
+
+export type CreateBranchInput = z.input<typeof CreateBranchInputSchema>;
+
+export async function createBranchHandler(args: CreateBranchInput) {
+  const params = CreateBranchInputSchema.parse(args);
+
+  // Ensure latest base branch
+  await runCommand("git", ["fetch", "origin", params.baseBranch]);
+
+  // Create branch from origin base branch
+  const result = await runCommand("git", ["checkout", "-b", params.branchName, `origin/${params.baseBranch}`]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to create branch ${params.branchName}: ${result.stderr}`);
+  }
+
+  return {
+    success: true,
+    branchName: params.branchName,
+    baseBranch: params.baseBranch
+  };
+}

package/src/tools/repo.create_repair_branch.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { createWorktree } from "../lib/git.js";
+
+export const CreateRepairBranchInputSchema = z.object({
+  prNumber: z.number(),
+  repairBranchName: z.string().optional(),
+  writeMode: z.boolean().optional().default(false),
+});
+
+export async function createRepairBranchHandler(args: z.infer<typeof CreateRepairBranchInputSchema>) {
+  if (!args.writeMode) {
+    throw new Error("writeMode must be true to create a repair branch.");
+  }
+  const prResult = await runCommand("gh", [
+    "pr",
+    "view",
+    args.prNumber.toString(),
+    "--json", "headRefName,baseRefName,title"
+  ]);
+
+  if (prResult.exitCode !== 0) {
+    throw new Error(`Failed to get PR info: ${prResult.stderr}`);
+  }
+
+  const { headRefName, baseRefName, title } = JSON.parse(prResult.stdout);
+
+  const sanitizedTitle = title.toLowerCase().replace(/[^a-z0-9]/g, "-").substring(0, 30);
+  const repairBranch = args.repairBranchName || `agent/repair-pr-${args.prNumber}-${sanitizedTitle}`;
+
+  // Ensure latest
+  await runCommand("git", ["fetch", "origin", headRefName]);
+  await runCommand("git", ["fetch", "origin", baseRefName]);
+
+  const worktreePath = await createWorktree(`origin/${headRefName}`, args.prNumber);
+
+  // Create the actual repair branch in the worktree
+  await runCommand("git", ["checkout", "-b", repairBranch], { cwd: worktreePath });
+
+  return {
+    prNumber: args.prNumber,
+    originalBranch: headRefName,
+    repairBranch,
+    baseBranch: baseRefName,
+    worktreePath
+  };
+}

package/src/tools/repo.get_changed_files.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+
+export const GetChangedFilesInputSchema = z.object({
+  base: z.string().optional().default("main"),
+  head: z.string().optional().default("HEAD"),
+});
+
+export async function getChangedFilesHandler(args: z.infer<typeof GetChangedFilesInputSchema>) {
+  const result = await runCommand("git", [
+    "diff",
+    "--name-status",
+    `${args.base}...${args.head}`
+  ]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to get changed files: ${result.stderr}`);
+  }
+
+  const files = result.stdout.trim().split("\n").filter(line => line.length > 0).map(line => {
+    const [status, path] = line.split(/\s+/);
+    return { status, path };
+  });
+
+  return { files };
+}

package/src/tools/repo.get_command_schema.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+
+export const GetCommandSchemaInputSchema = z.object({
+  commandPath: z.string().describe("The CLI command path to retrieve the schema for (e.g. 'gh audit-pr')"),
+});
+
+export async function getCommandSchemaHandler(args: z.infer<typeof GetCommandSchemaInputSchema>) {
+  // Sanitize input to prevent command injection (allow only alphanumeric, spaces, hyphens, and underscores)
+  const sanitizedPath = args.commandPath.replace(/[^a-zA-Z0-9-_ ]/g, "");
+  const result = await runCommand("td-cli", ["schema", sanitizedPath]);
+
+  if (result.exitCode !== 0) {
+    // Log stderr for debugging but don't expose it to the user
+    // Using comma-separated arguments to satisfy semgrep unsafe-formatstring
+    console.error("td-cli schema failed for", sanitizedPath, ":", result.stderr);
+    throw new Error(`Failed to get command schema for '${sanitizedPath}'`);
+  }
+
+  try {
+    const parsed = JSON.parse(result.stdout);
+    if (parsed.status === "error") {
+      throw new Error(parsed.message || "Failed to get command schema");
+    }
+    // Return the full payload (which contains the 'schema' object)
+    return parsed;
+  } catch (e) {
+    throw new Error(`Failed to parse command schema output: ${e}`);
+  }
+}

package/src/tools/repo.get_package_scripts.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi } from "vitest";
+import { getPackageScriptsHandler } from "./repo.get_package_scripts.js";
+import fs from "fs/promises";
+import { config } from "../config.js";
+
+vi.mock("fs/promises");
+
+describe("repo.get_package_scripts", () => {
+  it("should return scripts from package.json", async () => {
+    const mockPkg = {
+      scripts: { test: "vitest" }
+    };
+
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockPkg));
+
+    const result = await getPackageScriptsHandler({});
+    expect(result.scripts.test).toBe("vitest");
+  });
+
+  it("should handle missing scripts", async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
+
+    const result = await getPackageScriptsHandler({});
+    expect(result.scripts).toEqual({});
+  });
+
+  it("should throw error when file not found", async () => {
+    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 filter scripts by pattern", async () => {
+    const mockPkg = {
+      scripts: {
+        test: "vitest",
+        build: "vite build",
+        "test:ui": "vitest --ui"
+      }
+    };
+
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockPkg));
+
+    const result = await getPackageScriptsHandler({ filter: "test" });
+    expect(result.scripts).toEqual({
+      test: "vitest",
+      "test:ui": "vitest --ui"
+    });
+    expect(result.scripts.build).toBeUndefined();
+  });
+});

package/src/tools/repo.get_package_scripts.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import fs from "fs/promises";
+import path from "path";
+import { config } from "../config.js";
+
+export const GetPackageScriptsInputSchema = z.object({
+  filter: z.string().optional(),
+});
+
+export async function getPackageScriptsHandler(args: z.infer<typeof GetPackageScriptsInputSchema>) {
+  GetPackageScriptsInputSchema.parse(args);
+  const packageJsonPath = path.join(config.repoPath, "package.json");
+  try {
+    const content = await fs.readFile(packageJsonPath, "utf-8");
+    let pkg;
+    try {
+      pkg = JSON.parse(content);
+    } catch (e) {
+      throw new Error(`Malformed package.json: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    let scripts = pkg.scripts || {};
+    if (args.filter) {
+      const filtered: Record<string, string> = {};
+      for (const [name, cmd] of Object.entries(scripts)) {
+        if (name.includes(args.filter)) {
+          filtered[name] = cmd as string;
+        }
+      }
+      scripts = filtered;
+    }
+    return { scripts };
+  } catch (error) {
+    throw new Error(`Failed to read package.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tools/repo.get_route_map.ts

@@ -0,0 +1,41 @@
+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.logs.ts

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

package/src/tools/repo.read_agent_context.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { config } from "../config.js";
+
+export const ReadAgentContextInputSchema = z.object({});
+
+export async function readAgentContextHandler(_args: z.infer<typeof ReadAgentContextInputSchema>) {
+  const contextPath = path.join(config.repoPath, ".agent-context.json");
+
+  try {
+    const content = await fs.readFile(contextPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return {
+      status: "success",
+      ...parsed
+    };
+  } catch (e: any) {
+    console.error("Failed to read agent context:", e.message);
+    throw new Error(`Failed to read agent context from ${contextPath}. Ensure it exists by running 'td-cli context-warm'.`);
+  }
+}

package/src/tools/repo.read_ci_logs.ts

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

package/src/tools/repo.run_lighthouse.ts

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+
+export const RunPlaywrightInputSchema = z.object({
+  grep: z.string().optional(),
+  worktreePath: z.string().optional(),
+});
+
+export async function runPlaywrightHandler(args: z.infer<typeof RunPlaywrightInputSchema>) {
+  const tdArgs = ["repo", "run-playwright"];
+  if (args.grep) {
+    tdArgs.push("--grep", args.grep);
+  }
+  if (args.worktreePath) {
+    tdArgs.push("--worktree", args.worktreePath);
+  }
+
+  const result = await runCommand("td-cli", tdArgs);
+
+  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
+  };
+}

package/src/tools/repo.run_tests.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { runCommand, ShellResult } from "../lib/shell.js";
+
+export const RunTestsInputSchema = z.object({
+  commands: z.array(z.string()).optional(),
+  timeoutSeconds: z.number().optional().default(300),
+  worktreePath: z.string().optional(),
+});
+
+export async function runTestsHandler(args: z.infer<typeof RunTestsInputSchema>) {
+  const commands = args.commands || [
+    "pnpm install --frozen-lockfile",
+    "pnpm lint",
+    "pnpm test",
+    "pnpm build"
+  ];
+
+  const results: ShellResult[] = [];
+  let success = true;
+
+  for (const fullCmd of commands) {
+    const [cmd, ...cmdArgs] = fullCmd.split(" ");
+    try {
+      const res = await runCommand(cmd, cmdArgs, {
+        cwd: args.worktreePath,
+        timeout: args.timeoutSeconds * 1000
+      });
+      results.push(res);
+      if (res.exitCode !== 0) {
+        success = false;
+        break;
+      }
+    } catch (e) {
+      success = false;
+      results.push({
+        command: fullCmd,
+        stdout: "",
+        stderr: e instanceof Error ? e.message : String(e),
+        exitCode: 1,
+        durationMs: 0
+      });
+      break;
+    }
+  }
+
+  return { success, results };
+}

package/src/tools/types.ts

@@ -0,0 +1,8 @@
+export type JulesStatus = "PENDING" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
+
+export interface JulesSession {
+  id: string;
+  status: JulesStatus;
+  createdAt: Date;
+  pullRequestUrl?: string;
+}

package/start_browsermcp.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Start a dummy listener on port 9009 so that lsof -ti:9009 doesn't return empty and crash the server
+python3 -c "
+import socket, time
+try:
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind(('127.0.0.1', 9009))
+    s.listen(1)
+    time.sleep(2)
+except Exception:
+    pass
+" &
+sleep 0.2
+exec npx @browsermcp/mcp@latest "$@"

package/start_github_mcp.sh

@@ -0,0 +1,6 @@
+# Set the token and run the Docker container
+export GITHUB_TOKEN=$(gh auth token)
+docker run -i --rm \
+  -e GITHUB_PERSONAL_ACCESS_TOKEN="$GITHUB_TOKEN" \
+  -e GITHUB_TOOLSETS="actions,code_security,dependabot,issues,pull_requests,repos,search,security_advisories" \
+  ghcr.io/github/github-mcp-server:latest

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    exclude: ["node_modules", "dist"],
+  },
+});