@arii/boomtick-mcp 0.6.1 → 0.7.0

package/src/tools/github.comment_triage_summary.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
+import { runTDCli } from "./jules/cli.js";
 
 export const CommentTriageSummaryInputSchema = z.object({
   prNumber: z.number(),
@@ -7,21 +7,12 @@ export const CommentTriageSummaryInputSchema = z.object({
 });
 
 export async function commentTriageSummaryHandler(args: z.infer<typeof CommentTriageSummaryInputSchema>) {
-  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,

package/src/tools/github.get_merge_conflict_files.ts

@@ -12,10 +12,13 @@ export async function getMergeConflictFilesHandler(args: z.infer<typeof GetMerge
   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/src/tools/github.get_pr_diff.ts

@@ -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."),
@@ -11,20 +11,10 @@ export async function getPrDiffHandler(args: z.infer<typeof GetPrDiffInputSchema
   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
-  ]);
+  ], "get PR diff");
 
-  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
   return {
     prNumber: output.prNumber,
     files: output.files,

package/src/tools/jules/cancel-session.ts

@@ -1,22 +1,13 @@
 import { z } from "zod";
 import { JulesSession } from "../types.js";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
 
 export const CancelJulesSessionInputSchema = z.object({
   sessionId: z.string(),
 });
 
 export async function cancelJulesSessionHandler(input: z.infer<typeof CancelJulesSessionInputSchema>): Promise<JulesSession> {
-  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/", ""),

package/src/tools/jules/cli.ts

@@ -0,0 +1,42 @@
+import { runCommand } from "../../lib/shell.js";
+
+export interface TDCliResponse {
+  status?: string;
+  message?: string;
+  [key: string]: any;
+}
+
+function tryParseJson(text: string): TDCliResponse | null {
+  try {
+    return JSON.parse(text) as TDCliResponse;
+  } catch {
+    return null;
+  }
+}
+
+export async function runTDCli(args: string[], actionName?: string): Promise<TDCliResponse> {
+  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/src/tools/jules/create-session.test.ts

@@ -49,6 +49,15 @@ describe("createJulesSessionHandler", () => {
     ]);
   });
 
+  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/src/tools/jules/create-session.ts

@@ -5,12 +5,17 @@ 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: z.infer<typeof CreateJulesSessionInputSchema>) {
   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;
   }
 
@@ -18,6 +23,12 @@ export async function createJulesSessionHandler(input: z.infer<typeof CreateJule
       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/src/tools/jules/get-messages.ts

@@ -1,21 +1,12 @@
 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: z.infer<typeof GetJulesMessagesInputSchema>) {
-  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/", ""),

package/src/tools/jules/list-sessions.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { JulesSession, JulesStatus } from "../types.js";
-import { runCommand } from "../../lib/shell.js";
+import { JulesSession } from "../types.js";
+import { runTDCli } from "./cli.js";
+import { parseJulesSession } from "./session.js";
 
 export const ListJulesSessionsInputSchema = z.object({
   pageSize: z.number().optional(),
@@ -8,43 +9,8 @@ export const ListJulesSessionsInputSchema = z.object({
 });
 
 export async function listJulesSessionsHandler(input: z.infer<typeof ListJulesSessionsInputSchema>): Promise<JulesSession[]> {
-  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: any) => {
-    const name = session.name || "";
-    const id = name.startsWith("sessions/") ? name.substring(9) : name;
-
-    let status: JulesStatus = "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: string | undefined;
-    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: any) => parseJulesSession(session));
 }

package/src/tools/jules/send-message.ts

@@ -1,5 +1,5 @@
 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())]),
@@ -8,16 +8,7 @@ export const SendJulesMessageInputSchema = z.object({
 
 export async function sendJulesMessageHandler(input: z.infer<typeof SendJulesMessageInputSchema>) {
   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/", ""),

package/src/tools/jules/session.ts

@@ -0,0 +1,28 @@
+import { JulesSession, JulesStatus } from "../types.js";
+
+export function parseJulesSession(data: any): JulesSession {
+  const name = data.name || "";
+  const id = name.startsWith("sessions/") ? name.substring(9) : name;
+
+  let status: JulesStatus = "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: string | undefined;
+  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/src/tools/jules/shared.ts

@@ -1,63 +1,2 @@
-import { JulesSession, JulesStatus } from "../types.js";
-import { runCommand } from "../../lib/shell.js";
-
-export interface TDCliResponse {
-  status?: string;
-  message?: string;
-  [key: string]: any;
-}
-
-function tryParseJson(text: string): TDCliResponse | null {
-  try {
-    return JSON.parse(text) as TDCliResponse;
-  } catch {
-    return null;
-  }
-}
-
-export async function runTDCli(args: string[]): Promise<TDCliResponse> {
-  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: any): JulesSession {
-  const name = data.name || "";
-  const id = name.startsWith("sessions/") ? name.substring(9) : name;
-
-  let status: JulesStatus = "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: string | undefined;
-  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/src/tools/jules/trigger-feedback.ts

@@ -1,21 +1,10 @@
 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: z.infer<typeof TriggerJulesFeedbackInputSchema>) {
-  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/src/tools/repo.check_jules_status.test.ts

@@ -0,0 +1,55 @@
+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",
+            },
+          },
+        ],
+      }),
+    } as any);
+
+    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/src/tools/repo.check_jules_status.ts

@@ -0,0 +1,176 @@
+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 interface JulesStatusResult {
+  sessionId: string;
+  status: "COMPLETED" | "FAILED" | "IN_PROGRESS" | "TIMED_OUT" | "NOT_FOUND";
+  rawState?: string;
+  completed: boolean;
+  remediationBranch?: string;
+  pullRequestUrl?: string;
+  idempotencyHash?: string;
+  isDuplicate?: boolean;
+  message?: string;
+}
+
+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: string, failureLog: string): string {
+  const hash = crypto.createHash("sha256");
+  return hash.update(`${commitSha}:${failureLog.trim()}`).digest("hex");
+}
+
+export async function checkJulesStatusHandler(input: z.infer<typeof CheckJulesStatusInputSchema>): Promise<JulesStatusResult> {
+  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: string | undefined;
+  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: any = 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: JulesStatusResult["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: string | undefined;
+    let pullRequestUrl: string | undefined;
+
+    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/src/tools/repo.multi_exec.test.ts

@@ -0,0 +1,15 @@
+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");
+  });
+});