@arii/boomtick-mcp 0.6.1 → 0.7.0

package/dist/tools/github.comment_triage_summary.js

@@ -1,23 +1,16 @@
 import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
+import { runTDCli } from "./jules/cli.js";
 export const CommentTriageSummaryInputSchema = z.object({
     prNumber: z.number(),
     body: z.string(),
 });
 export async function commentTriageSummaryHandler(args) {
-    const result = await runCommand("td", [
+    const output = await runTDCli([
         "gh",
         "post-comment",
         "--pr", args.prNumber.toString(),
         "--body", args.body
-    ]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to comment on PR: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to comment on PR: ${output.message}`);
-    }
+    ], "comment on PR");
     return {
         success: true,
         commentUrl: output.html_url || output.url

package/dist/tools/github.get_merge_conflict_files.js

@@ -9,10 +9,12 @@ export async function getMergeConflictFilesHandler(args) {
     const baseBranch = args.baseBranch || "main";
     const headRef = args.headRef || "HEAD";
     const conflictFiles = await getMergeConflictFiles(baseBranch, headRef);
+    const hasConflicts = conflictFiles.length > 0;
     return {
-        prNumber: args.prNumber,
+        hasConflicts,
+        conflictedFiles: conflictFiles,
+        prNumber: args.prNumber ?? null,
         baseBranch,
         headRef,
-        conflictFiles,
     };
 }

package/dist/tools/github.get_pr_diff.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
 import { resolveRepo } from "../lib/git.js";
+import { runTDCli } from "./jules/cli.js";
 export const GetPrDiffInputSchema = z.object({
     prNumber: z.number().describe("The number of the pull request to get the diff for."),
     repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
@@ -8,17 +8,9 @@ export const GetPrDiffInputSchema = z.object({
 export async function getPrDiffHandler(args) {
     const params = GetPrDiffInputSchema.parse(args);
     const targetRepo = resolveRepo(params.repo);
-    const result = await runCommand("td", [
+    const output = await runTDCli([
         "gh", "pr-diff", params.prNumber.toString(), "--repo", targetRepo
-    ]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to get PR diff: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to get PR diff: ${output.message}`);
-    }
-    // Every TypeScript tool file must be a pure routing shim
+    ], "get PR diff");
     return {
         prNumber: output.prNumber,
         files: output.files,

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

@@ -1,17 +1,10 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
 export const CancelJulesSessionInputSchema = z.object({
     sessionId: z.string(),
 });
 export async function cancelJulesSessionHandler(input) {
-    const result = await runCommand("td", ["agent", "cancel", input.sessionId]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to cancel session: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to cancel session: ${output.message}`);
-    }
+    await runTDCli(["agent", "cancel", input.sessionId], "cancel session");
     return {
         id: input.sessionId.replace("sessions/", ""),
         status: "FAILED",

package/dist/tools/jules/cli.js

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

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

@@ -4,16 +4,26 @@ export const CreateJulesSessionInputSchema = z.object({
     task: z.string(),
     branch: z.string().optional(),
     pr: z.number().optional(),
+    repo: z.string().optional(),
 });
 export async function createJulesSessionHandler(input) {
     let branch = input.branch;
     if (!branch && input.pr) {
-        const prData = await runTDCli(["gh", "view", input.pr.toString()]);
+        const ghArgs = ["gh", "view", input.pr.toString()];
+        if (input.repo) {
+            ghArgs.push("--repo", input.repo);
+        }
+        const prData = await runTDCli(ghArgs);
         branch = prData.pr.headRefName;
     }
     if (!branch) {
         branch = process.env.DEFAULT_BASE_BRANCH || "main";
     }
-    const output = await runTDCli(["agent", "dispatch", branch, input.task]);
+    const dispatchArgs = ["agent", "dispatch"];
+    if (input.repo) {
+        dispatchArgs.push("--repo", input.repo);
+    }
+    dispatchArgs.push(branch, input.task);
+    const output = await runTDCli(dispatchArgs);
     return parseJulesSession(output.session || output);
 }

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

@@ -41,6 +41,13 @@ describe("createJulesSessionHandler", () => {
             "agent", "dispatch", "feature-x", "do work"
         ]);
     });
+    it("should create a session with repo parameter", async () => {
+        const result = await createJulesSessionHandler({ task: "do work", branch: "main", repo: "arii/portfolio" });
+        expect(result.id).toBe("1234567890");
+        expect(shell.runCommand).toHaveBeenCalledWith("td", [
+            "agent", "dispatch", "--repo", "arii/portfolio", "main", "do work"
+        ]);
+    });
     it("should create a session with PR number", async () => {
         vi.mocked(shell.runCommand).mockImplementation(async (cmd, args) => {
             if (args[1] === "view") {

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

@@ -1,17 +1,10 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
 export const GetJulesMessagesInputSchema = z.object({
     sessionId: z.string(),
 });
 export async function getJulesMessagesHandler(input) {
-    const result = await runCommand("td", ["agent", "messages", input.sessionId]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to get messages: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to get messages: ${output.message}`);
-    }
+    const output = await runTDCli(["agent", "messages", input.sessionId], "get messages");
     return {
         id: input.sessionId.replace("sessions/", ""),
         messages: output.messages,

package/dist/tools/jules/list-sessions.js

@@ -1,43 +1,12 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
+import { parseJulesSession } from "./session.js";
 export const ListJulesSessionsInputSchema = z.object({
     pageSize: z.number().optional(),
     pageToken: z.string().optional(),
 });
 export async function listJulesSessionsHandler(input) {
-    const result = await runCommand("td", ["agent", "sync"]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to list sessions: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to list sessions: ${output.message}`);
-    }
+    const output = await runTDCli(["agent", "sync"], "list sessions");
     const sessions = output.sessions || [];
-    return sessions.map((session) => {
-        const name = session.name || "";
-        const id = name.startsWith("sessions/") ? name.substring(9) : name;
-        let status = "PENDING";
-        if (session.state === "SUCCEEDED" || session.state === "COMPLETED")
-            status = "COMPLETED";
-        else if (session.state === "FAILED" || session.state === "CANCELLED" || session.state === "TERMINATED")
-            status = "FAILED";
-        else if (session.state === "IN_PROGRESS")
-            status = "IN_PROGRESS";
-        let pullRequestUrl;
-        if (session.outputs && Array.isArray(session.outputs)) {
-            for (const out of session.outputs) {
-                if (out.pullRequest && out.pullRequest.url) {
-                    pullRequestUrl = out.pullRequest.url;
-                    break;
-                }
-            }
-        }
-        return {
-            id,
-            status,
-            createdAt: session.createTime ? new Date(session.createTime) : new Date(),
-            pullRequestUrl,
-        };
-    });
+    return sessions.map((session) => parseJulesSession(session));
 }

package/dist/tools/jules/send-message.js

@@ -1,19 +1,12 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
 export const SendJulesMessageInputSchema = z.object({
     sessionId: z.union([z.string(), z.array(z.string())]),
     message: z.string(),
 });
 export async function sendJulesMessageHandler(input) {
     const sessionIds = Array.isArray(input.sessionId) ? input.sessionId.join(",") : input.sessionId;
-    const result = await runCommand("td", ["agent", "send", sessionIds, input.message]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to send message: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to send message: ${output.message}`);
-    }
+    await runTDCli(["agent", "send", sessionIds, input.message], "send message");
     return {
         id: Array.isArray(input.sessionId) ? input.sessionId.map(id => id.replace("sessions/", "")) : input.sessionId.replace("sessions/", ""),
         status: "success",

package/dist/tools/jules/session.js

@@ -0,0 +1,26 @@
+export function parseJulesSession(data) {
+    const name = data.name || "";
+    const id = name.startsWith("sessions/") ? name.substring(9) : name;
+    let status = "PENDING";
+    if (data.state === "SUCCEEDED" || data.state === "COMPLETED")
+        status = "COMPLETED";
+    else if (data.state === "FAILED" || data.state === "CANCELLED" || data.state === "TERMINATED")
+        status = "FAILED";
+    else if (data.state === "IN_PROGRESS")
+        status = "IN_PROGRESS";
+    let pullRequestUrl;
+    if (data.outputs && Array.isArray(data.outputs)) {
+        for (const out of data.outputs) {
+            if (out.pullRequest && out.pullRequest.url) {
+                pullRequestUrl = out.pullRequest.url;
+                break;
+            }
+        }
+    }
+    return {
+        id,
+        status,
+        createdAt: data.createTime ? new Date(data.createTime) : new Date(),
+        pullRequestUrl,
+    };
+}

package/dist/tools/jules/shared.js

@@ -1,50 +1,2 @@
-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", args);
-    const stdout = result.stdout.trim();
-    const output = stdout.startsWith("{") ? tryParseJson(stdout) : null;
-    if (output?.status === "error") {
-        throw new Error(`td returned error: ${output.message ?? "Unknown error"}`);
-    }
-    if (result.exitCode !== 0) {
-        throw new Error(`td command failed (${args.join(" ")}): ${result.stderr || stdout}`);
-    }
-    if (!output) {
-        throw new Error(`td 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;
-    let status = "PENDING";
-    if (data.state === "SUCCEEDED" || data.state === "COMPLETED")
-        status = "COMPLETED";
-    else if (data.state === "FAILED" || data.state === "CANCELLED" || data.state === "TERMINATED")
-        status = "FAILED";
-    else if (data.state === "IN_PROGRESS")
-        status = "IN_PROGRESS";
-    let pullRequestUrl;
-    if (data.outputs && Array.isArray(data.outputs)) {
-        for (const out of data.outputs) {
-            if (out.pullRequest && out.pullRequest.url) {
-                pullRequestUrl = out.pullRequest.url;
-                break;
-            }
-        }
-    }
-    return {
-        id,
-        status,
-        createdAt: data.createTime ? new Date(data.createTime) : new Date(),
-        pullRequestUrl,
-    };
-}
+export * from "./cli.js";
+export * from "./session.js";

package/dist/tools/jules/trigger-feedback.js

@@ -1,16 +1,8 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
 export const TriggerJulesFeedbackInputSchema = z.object({
     sessionId: z.string(),
 });
 export async function triggerJulesFeedbackHandler(input) {
-    const result = await runCommand("td", ["agent", "trigger-feedback", input.sessionId]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to trigger feedback: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to trigger feedback: ${output.message}`);
-    }
-    return output;
+    return await runTDCli(["agent", "trigger-feedback", input.sessionId], "trigger feedback");
 }

package/dist/tools/repo.check_jules_status.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { config } from "../config.js";
+export const CheckJulesStatusInputSchema = z.object({
+    sessionId: z.string().optional().describe("The unique ID or task ID of the Jules session."),
+    commitSha: z.string().optional().describe("Commit SHA for idempotency key verification."),
+    failureLog: z.string().optional().describe("Failure log content for idempotency key calculation."),
+    poll: z.boolean().optional().describe("Whether to poll until session completion or timeout."),
+    timeoutMs: z.number().int().optional().describe("Timeout in milliseconds when polling."),
+    intervalMs: z.number().int().optional().describe("Polling interval in milliseconds."),
+});
+function calculateHash(commitSha, failureLog) {
+    const hash = crypto.createHash("sha256");
+    return hash.update(`${commitSha}:${failureLog.trim()}`).digest("hex");
+}
+export async function checkJulesStatusHandler(input) {
+    let resolvedTaskId = input.sessionId || process.env.TASK_ID;
+    if (!resolvedTaskId) {
+        return {
+            sessionId: "",
+            status: "NOT_FOUND",
+            completed: false,
+            message: "No session ID provided.",
+        };
+    }
+    const sessionId = resolvedTaskId.startsWith("sessions/") ? resolvedTaskId : `sessions/${resolvedTaskId}`;
+    const apiKey = process.env.JULES_API_KEY;
+    if (!apiKey) {
+        return {
+            sessionId,
+            status: "NOT_FOUND",
+            completed: false,
+            message: "JULES_API_KEY environment variable not set.",
+        };
+    }
+    const commitSha = input.commitSha || process.env.GITHUB_SHA || process.env.COMMIT_SHA;
+    let idempotencyHash;
+    let isDuplicate = false;
+    if (commitSha && input.failureLog) {
+        idempotencyHash = calculateHash(commitSha, input.failureLog);
+        const artifactsDir = path.join(config.repoPath || process.cwd(), "artifacts");
+        const hashTrackingFile = path.join(artifactsDir, `.jules-dispatch-${sessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}.hash`);
+        if (fs.existsSync(hashTrackingFile)) {
+            try {
+                const existingHash = fs.readFileSync(hashTrackingFile, "utf8").trim();
+                if (existingHash === idempotencyHash) {
+                    isDuplicate = true;
+                }
+            }
+            catch (e) {
+                console.warn("⚠️ Could not read previous Jules dispatch hash file during status check:", e);
+            }
+        }
+    }
+    const url = `https://jules.googleapis.com/v1alpha/${sessionId}`;
+    const poll = input.poll ?? false;
+    const timeoutMs = input.timeoutMs ?? 60000;
+    const intervalMs = input.intervalMs ?? 5000;
+    const startTime = Date.now();
+    const fetchSession = async () => {
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-goog-api-key": apiKey,
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return await response.json();
+    };
+    while (true) {
+        let sessionData = null;
+        try {
+            sessionData = await fetchSession();
+        }
+        catch (e) {
+            console.warn(`⚠️ Error fetching Jules session status for ${sessionId}:`, e);
+        }
+        if (!sessionData) {
+            return {
+                sessionId,
+                status: "NOT_FOUND",
+                completed: false,
+                idempotencyHash,
+                isDuplicate,
+                message: `Failed to retrieve session data for ${sessionId}`,
+            };
+        }
+        const rawState = sessionData.state || "UNKNOWN";
+        let status = "IN_PROGRESS";
+        if (rawState === "SUCCEEDED" || rawState === "COMPLETED") {
+            status = "COMPLETED";
+        }
+        else if (rawState === "FAILED" || rawState === "CANCELLED" || rawState === "TERMINATED") {
+            status = "FAILED";
+        }
+        else if (rawState === "IN_PROGRESS" || rawState === "PENDING") {
+            status = "IN_PROGRESS";
+        }
+        let remediationBranch;
+        let pullRequestUrl;
+        if (sessionData.sourceContext?.githubRepoContext?.startingBranch) {
+            remediationBranch = sessionData.sourceContext.githubRepoContext.startingBranch;
+        }
+        if (Array.isArray(sessionData.outputs)) {
+            for (const output of sessionData.outputs) {
+                if (output?.pullRequest?.url) {
+                    pullRequestUrl = output.pullRequest.url;
+                }
+                if (output?.pullRequest?.branch || output?.gitBranch) {
+                    remediationBranch = output?.pullRequest?.branch || output?.gitBranch;
+                }
+            }
+        }
+        const completed = status === "COMPLETED";
+        if (!poll || status === "COMPLETED" || status === "FAILED") {
+            return {
+                sessionId,
+                status,
+                rawState,
+                completed,
+                remediationBranch,
+                pullRequestUrl,
+                idempotencyHash,
+                isDuplicate,
+                message: `Session state: ${rawState}`,
+            };
+        }
+        if (Date.now() - startTime >= timeoutMs) {
+            return {
+                sessionId,
+                status: "TIMED_OUT",
+                rawState,
+                completed: false,
+                remediationBranch,
+                pullRequestUrl,
+                idempotencyHash,
+                isDuplicate,
+                message: `Polling timed out after ${timeoutMs}ms (current state: ${rawState})`,
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}

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

@@ -0,0 +1,47 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { checkJulesStatusHandler } from "./repo.check_jules_status.js";
+describe("repo.check_jules_status MCP Tool Handler", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.env = { ...originalEnv };
+        delete process.env.TASK_ID;
+        delete process.env.JULES_API_KEY;
+        global.fetch = vi.fn();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        vi.restoreAllMocks();
+    });
+    it("returns NOT_FOUND status if no session ID or JULES_API_KEY is available", async () => {
+        const result = await checkJulesStatusHandler({});
+        expect(result.status).toBe("NOT_FOUND");
+        expect(result.completed).toBe(false);
+    });
+    it("checks Jules session status and returns response object", async () => {
+        process.env.JULES_API_KEY = "test-api-key";
+        vi.mocked(global.fetch).mockResolvedValue({
+            ok: true,
+            json: vi.fn().mockResolvedValue({
+                name: "sessions/test-session-123",
+                state: "SUCCEEDED",
+                outputs: [
+                    {
+                        pullRequest: {
+                            url: "https://github.com/org/repo/pull/100",
+                            branch: "remediation-branch-123",
+                        },
+                    },
+                ],
+            }),
+        });
+        const result = await checkJulesStatusHandler({
+            sessionId: "test-session-123",
+        });
+        expect(result.sessionId).toBe("sessions/test-session-123");
+        expect(result.status).toBe("COMPLETED");
+        expect(result.completed).toBe(true);
+        expect(result.remediationBranch).toBe("remediation-branch-123");
+        expect(result.pullRequestUrl).toBe("https://github.com/org/repo/pull/100");
+    });
+});

package/dist/tools/repo.multi_exec.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { runTDCli } from "./jules/shared.js";
+export const MultiExecInputSchema = z.object({
+    command: z.string().describe("Shell command to execute sequentially across repositories"),
+    repos: z.array(z.string()).optional().describe("Optional list of repository names to target"),
+    continueOnError: z.boolean().optional().default(true).describe("Whether to continue execution if a repo command fails"),
+});
+export async function multiExecHandler(input) {
+    const args = MultiExecInputSchema.parse(input);
+    const cliArgs = ["multi-repo", "exec", args.command];
+    if (args.repos) {
+        for (const r of args.repos) {
+            cliArgs.push("-r", r);
+        }
+    }
+    if (args.continueOnError === false) {
+        cliArgs.push("--fail-fast");
+    }
+    const output = await runTDCli(cliArgs, "execute command across ecosystem repositories");
+    return output;
+}

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

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { multiExecHandler } from "./repo.multi_exec.js";
+describe("MultiExec Tool", () => {
+    it("should execute a command sequentially across repositories", async () => {
+        const res = await multiExecHandler({
+            command: "echo test-vitest-exec",
+            repos: ["arii/boomtick"],
+        });
+        expect(res.status).toBe("success");
+        expect(res.total_repos).toBe(1);
+        expect(res.results[0].stdout).toContain("test-vitest-exec");
+    });
+});