@arii/boomtick-mcp 0.4.1 → 0.5.0

package/dist/tools/github.get_pr_reviews.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getPrReviewsHandler } from "./github.get_pr_reviews.js";
+import { getPrCommitsHandler } from "./github.get_pr_commits.js";
+import { getWorkflowRunsHandler } from "./repo.get_workflow_runs.js";
+import * as shell from "../lib/shell.js";
+vi.mock("../lib/shell.js", () => ({
+    runCommand: vi.fn(),
+}));
+describe("MCP GitHub tools", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("getPrReviewsHandler", () => {
+        it("should fetch PR reviews via td-cli gh read-pr-reviews", async () => {
+            vi.mocked(shell.runCommand).mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    status: "success",
+                    reviews: [{ id: 1, state: "APPROVED", body: "LGTM" }],
+                    review_count: 1,
+                }),
+                stderr: "",
+                exitCode: 0,
+                durationMs: 10,
+                command: "td-cli gh read-pr-reviews",
+            });
+            const res = await getPrReviewsHandler({ prNumber: 819, repo: "arii/boomtick" });
+            expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+                "gh",
+                "read-pr-reviews",
+                "--pr-number",
+                "819",
+                "--repo",
+                "arii/boomtick",
+            ]);
+            expect(res).toEqual({
+                reviews: [{ id: 1, state: "APPROVED", body: "LGTM" }],
+                reviewCount: 1,
+            });
+        });
+    });
+    describe("getPrCommitsHandler", () => {
+        it("should list PR commits via td-cli gh list-pr-commits", async () => {
+            vi.mocked(shell.runCommand).mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    status: "success",
+                    commits: [{ sha: "abc1234", author: "Dev", message: "feat: test" }],
+                }),
+                stderr: "",
+                exitCode: 0,
+                durationMs: 10,
+                command: "td-cli gh list-pr-commits",
+            });
+            const res = await getPrCommitsHandler({ prNumber: 819, repo: "arii/boomtick" });
+            expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+                "gh",
+                "list-pr-commits",
+                "--pr-number",
+                "819",
+                "--repo",
+                "arii/boomtick",
+            ]);
+            expect(res).toEqual({
+                commits: [{ sha: "abc1234", author: "Dev", message: "feat: test" }],
+            });
+        });
+    });
+    describe("getWorkflowRunsHandler", () => {
+        it("should fetch workflow runs via td-cli repo workflow-runs", async () => {
+            vi.mocked(shell.runCommand).mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    status: "success",
+                    workflow_runs: [{ id: 10, name: "CI" }],
+                }),
+                stderr: "",
+                exitCode: 0,
+                durationMs: 10,
+                command: "td-cli repo workflow-runs",
+            });
+            const res = await getWorkflowRunsHandler({
+                branch: "main",
+                event: "push",
+                repo: "arii/boomtick",
+            });
+            expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+                "repo",
+                "workflow-runs",
+                "--repo",
+                "arii/boomtick",
+                "--branch",
+                "main",
+                "--event",
+                "push",
+            ]);
+            expect(res).toEqual({
+                workflowRuns: [{ id: 10, name: "CI" }],
+            });
+        });
+    });
+});

package/dist/tools/github.issue_comment.js

@@ -1,9 +1,11 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
 import { sanitizeError } from "../lib/error_utils.js";
 export const IssueCommentInputSchema = z.object({
     issueNumber: z.number().describe("The number of the issue to comment on."),
     body: z.string().min(1, "Comment body cannot be empty").describe("The content of the comment."),
+    repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
 });
 const IssueCommentOutputSchema = z.object({
     status: z.string(),
@@ -12,7 +14,12 @@ const IssueCommentOutputSchema = z.object({
 });
 export async function issueCommentHandler(args) {
     const params = IssueCommentInputSchema.parse(args);
-    const result = await runCommand("td-cli", ["gh", "issue-comment", params.issueNumber.toString(), "--body", params.body]);
+    const targetRepo = resolveRepo(params.repo);
+    const result = await runCommand("td-cli", [
+        "gh", "issue-comment", params.issueNumber.toString(),
+        "--body", params.body,
+        "--repo", targetRepo
+    ]);
     if (result.exitCode !== 0) {
         throw new Error(`Failed to post comment: ${sanitizeError(result.stderr)}`);
     }

package/dist/tools/github.issue_update.js

@@ -1,9 +1,11 @@
 import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
 import { sanitizeError } from "../lib/error_utils.js";
 import { IssueUpdateInputSchema, IssueUpdateResponseSchema } from "./contract.js";
 export { IssueUpdateInputSchema };
 export async function issueUpdateHandler(args) {
     const params = IssueUpdateInputSchema.parse(args);
+    const targetRepo = resolveRepo(params.repo);
     const cmdArgs = ["gh", "issue-update", params.issueNumber.toString()];
     if (params.body)
         cmdArgs.push("--body", params.body);
@@ -17,6 +19,7 @@ export async function issueUpdateHandler(args) {
         cmdArgs.push("--remove-labels", params.removeLabels.join(","));
     if (params.state)
         cmdArgs.push("--state", params.state);
+    cmdArgs.push("--repo", targetRepo);
     const result = await runCommand("td-cli", cmdArgs);
     if (result.exitCode !== 0) {
         throw new Error(`Failed to update issue: ${sanitizeError(result.stderr)}`);

package/dist/tools/github.issue_view.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
 import { sanitizeError } from "../lib/error_utils.js";
 export const IssueViewInputSchema = z.object({
     issueNumber: z.number().describe("The number of the issue to view."),
+    repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
 });
 const IssueViewOutputSchema = z.object({
     status: z.string(),
@@ -16,7 +18,8 @@ const IssueViewOutputSchema = z.object({
 });
 export async function issueViewHandler(args) {
     const params = IssueViewInputSchema.parse(args);
-    const result = await runCommand("td-cli", ["gh", "issue-view", params.issueNumber.toString()]);
+    const targetRepo = resolveRepo(params.repo);
+    const result = await runCommand("td-cli", ["gh", "issue-view", params.issueNumber.toString(), "--repo", targetRepo]);
     if (result.exitCode !== 0) {
         throw new Error(`Failed to view issue: ${sanitizeError(result.stderr)}`);
     }

package/dist/tools/github.search_open_prs.js

@@ -1,17 +1,21 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
 export const SearchOpenPrsInputSchema = z.object({
     state: z.enum(["open", "closed", "all"]).optional().default("open"),
     includeDrafts: z.boolean().optional().default(true),
     limit: z.number().min(1).max(100).optional().default(100),
     labels: z.array(z.string()).optional(),
+    repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
 });
 export async function searchOpenPrsHandler(args) {
     const params = SearchOpenPrsInputSchema.parse(args);
+    const targetRepo = resolveRepo(params.repo);
     const tdArgs = [
         "gh", "search-prs",
         "--state", params.state,
         "--limit", params.limit.toString(),
+        "--repo", targetRepo,
     ];
     if (!params.includeDrafts) {
         tdArgs.push("--no-include-drafts");

package/dist/tools/jules/create-session.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { runTDCli } from "../../lib/td-cli.js";
-import { parseJulesSession } from "./shared.js";
+import { runTDCli, parseJulesSession } from "./shared.js";
 export const CreateJulesSessionInputSchema = z.object({
     task: z.string(),
     branch: z.string().optional(),

package/dist/tools/jules/get-pr.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { runTDCli } from "../../lib/td-cli.js";
-import { parseJulesSession } from "./shared.js";
+import { runTDCli, parseJulesSession } from "./shared.js";
 export const GetJulesPullRequestInputSchema = z.object({
     sessionId: z.string(),
 });

package/dist/tools/jules/get-session.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { runTDCli } from "../../lib/td-cli.js";
-import { parseJulesSession } from "./shared.js";
+import { runTDCli, parseJulesSession } from "./shared.js";
 export const GetJulesSessionInputSchema = z.object({
     sessionId: z.string(),
 });

package/dist/tools/jules/shared.js

@@ -1,3 +1,27 @@
+import { runCommand } from "../../lib/shell.js";
+function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export async function runTDCli(args) {
+    const result = await runCommand("td-cli", args);
+    const stdout = result.stdout.trim();
+    const output = stdout.startsWith("{") ? tryParseJson(stdout) : null;
+    if (output?.status === "error") {
+        throw new Error(`td-cli returned error: ${output.message ?? "Unknown error"}`);
+    }
+    if (result.exitCode !== 0) {
+        throw new Error(`td-cli command failed (${args.join(" ")}): ${result.stderr || stdout}`);
+    }
+    if (!output) {
+        throw new Error(`td-cli returned non-JSON output with exit code 0: ${stdout}`);
+    }
+    return output;
+}
 export function parseJulesSession(data) {
     const name = data.name || "";
     const id = name.startsWith("sessions/") ? name.substring(9) : name;

package/dist/tools/repo.commit_patch.js

@@ -1,33 +1,53 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { config } from "../config.js";
 export const CommitPatchInputSchema = z.object({
-    worktreePath: z.string(),
+    worktreePath: z.string().optional(),
     message: z.string(),
     allowedFiles: z.array(z.string()),
-    writeMode: z.boolean().optional().default(false),
+    writeMode: z.boolean().optional().default(true),
 });
 export async function commitPatchHandler(args) {
-    if (!args.writeMode) {
+    const parsed = CommitPatchInputSchema.parse(args || {});
+    const worktreePath = parsed.worktreePath || config.repoPath;
+    if (parsed.writeMode === false) {
         throw new Error("writeMode must be true to commit changes.");
     }
-    const statusResult = await runCommand("git", ["status", "--porcelain"], { cwd: args.worktreePath });
-    const changedFiles = statusResult.stdout.trim().split("\n").filter(l => l.length > 0).map(l => l.substring(3));
-    const forbiddenFiles = changedFiles.filter(f => !args.allowedFiles.includes(f));
+    const statusResult = await runCommand("git", ["status", "--porcelain"], { cwd: worktreePath });
+    const changedFiles = statusResult.stdout
+        .split("\n")
+        .map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l))
+        .filter((l) => l.trim().length > 0)
+        .map((l) => {
+        const match = l.match(/^..\s+(.*)$/);
+        if (!match)
+            return l.slice(3).trim();
+        let file = match[1].trim();
+        if (file.includes(" -> ")) {
+            file = file.split(" -> ").pop().trim();
+        }
+        if (file.startsWith('"') && file.endsWith('"')) {
+            file = file.slice(1, -1);
+        }
+        return file;
+    })
+        .filter(Boolean);
+    const forbiddenFiles = changedFiles.filter((f) => !parsed.allowedFiles.includes(f));
     if (forbiddenFiles.length > 0) {
         throw new Error(`The following files are not in the allowed list: ${forbiddenFiles.join(", ")}`);
     }
     if (changedFiles.length === 0) {
         throw new Error("No changes to commit.");
     }
-    await runCommand("git", ["add", "."], { cwd: args.worktreePath });
-    const commitResult = await runCommand("git", ["commit", "-m", args.message], { cwd: args.worktreePath });
+    await runCommand("git", ["add", "--", ...changedFiles], { cwd: worktreePath });
+    const commitResult = await runCommand("git", ["commit", "-m", parsed.message], { cwd: worktreePath });
     if (commitResult.exitCode !== 0) {
         throw new Error(`Failed to commit: ${commitResult.stderr}`);
     }
-    const shaResult = await runCommand("git", ["rev-parse", "HEAD"], { cwd: args.worktreePath });
+    const shaResult = await runCommand("git", ["rev-parse", "HEAD"], { cwd: worktreePath });
     return {
         success: true,
         commitSha: shaResult.stdout.trim(),
-        changedFiles
+        changedFiles,
     };
 }

package/dist/tools/repo.get_changed_files.js

@@ -1,21 +1,10 @@
 import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
+import { getChangedFiles } from "../lib/git.js";
 export const GetChangedFilesInputSchema = z.object({
     base: z.string().optional().default("main"),
     head: z.string().optional().default("HEAD"),
 });
 export async function getChangedFilesHandler(args) {
-    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 };
-    });
+    const files = await getChangedFiles(args.base || "main", args.head || "HEAD");
     return { files };
 }

package/dist/tools/repo.get_workflow_runs.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
+import { sanitizeError } from "../lib/error_utils.js";
+const GetWorkflowRunsInputSchema = z.object({
+    branch: z.string().optional().describe("Filter workflow runs by branch name."),
+    event: z.string().optional().describe("Filter workflow runs by event (e.g. push, pull_request)."),
+    repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
+});
+export async function getWorkflowRunsHandler(args) {
+    const params = GetWorkflowRunsInputSchema.parse(args);
+    const targetRepo = resolveRepo(params.repo);
+    const cliArgs = ["repo", "workflow-runs", "--repo", targetRepo];
+    if (params.branch) {
+        cliArgs.push("--branch", params.branch);
+    }
+    if (params.event) {
+        cliArgs.push("--event", params.event);
+    }
+    const result = await runCommand("td-cli", cliArgs);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to fetch workflow runs: ${sanitizeError(result.stderr)}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to fetch workflow runs: ${output.message}`);
+    }
+    return { workflowRuns: output.workflow_runs };
+}

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,8 +5,30 @@ export const RunTestsInputSchema = z.object({
     timeoutSeconds: z.number().optional().default(300),
     worktreePath: z.string().optional(),
 });
+function parseCommandArguments(fullCmd) {
+    const tokens = [];
+    const regex = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g;
+    let match;
+    while ((match = regex.exec(fullCmd)) !== null) {
+        if (match[1] !== undefined) {
+            tokens.push(match[1].replace(/\\"/g, '"'));
+        }
+        else if (match[2] !== undefined) {
+            tokens.push(match[2].replace(/\\'/g, "'"));
+        }
+        else {
+            tokens.push(match[3]);
+        }
+    }
+    if (tokens.length === 0) {
+        return ["", []];
+    }
+    const [cmd, ...args] = tokens;
+    return [cmd, args];
+}
 export async function runTestsHandler(args) {
-    const commands = args.commands || [
+    const parsed = RunTestsInputSchema.parse(args || {});
+    const commands = parsed.commands || [
         "pnpm install --frozen-lockfile",
         "pnpm lint",
         "pnpm test",
@@ -15,11 +37,11 @@ export async function runTestsHandler(args) {
     const results = [];
     let success = true;
     for (const fullCmd of commands) {
-        const [cmd, ...cmdArgs] = fullCmd.split(" ");
+        const [cmd, cmdArgs] = parseCommandArguments(fullCmd);
         try {
             const res = await runCommand(cmd, cmdArgs, {
-                cwd: args.worktreePath,
-                timeout: args.timeoutSeconds * 1000
+                cwd: parsed.worktreePath,
+                timeout: parsed.timeoutSeconds * 1000
             });
             results.push(res);
             if (res.exitCode !== 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.4.1",
+  "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,17 +26,15 @@
   "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 && vitest run",
+    "test": "tsx scripts/sync-contracts.ts && tsx scripts/sync-mcp-schemas.ts && vitest run",
     "run-evals": "node dist/evals/run-evals.js",
     "sync:mcp-schemas": "tsx scripts/sync-mcp-schemas.ts",
     "release:patch": "pnpm version patch",

package/scripts/sync-mcp-schemas.ts

@@ -69,7 +69,12 @@ async function syncSchemas() {
   }
 
   mcpTools.forEach((tool) => {
-    const schemaContent = JSON.stringify(tool.inputSchema, null, 2);
+    const exportedSchema = {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema,
+    };
+    const schemaContent = JSON.stringify(exportedSchema, null, 2);
     const fileName = `${tool.name}.json`;
 
     validTargets.forEach(targetDir => {

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