@arii/boomtick-mcp 0.3.3

package/src/tools/github.search_open_prs.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.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(),
+});
+
+export async function searchOpenPrsHandler(args: z.infer<typeof SearchOpenPrsInputSchema>) {
+  const params = SearchOpenPrsInputSchema.parse(args);
+
+  const tdArgs = [
+    "gh", "search-prs",
+    "--state", params.state,
+    "--limit", params.limit.toString(),
+  ];
+
+  if (!params.includeDrafts) {
+    tdArgs.push("--no-include-drafts");
+  }
+
+  if (params.labels && params.labels.length > 0) {
+    tdArgs.push("--labels", params.labels.join(","));
+  }
+
+  const result = await runCommand("td-cli", tdArgs);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to list PRs: ${result.stderr}`);
+  }
+
+  const output = JSON.parse(result.stdout);
+  if (output.status === "error") {
+    throw new Error(`Failed to list PRs: ${output.message}`);
+  }
+
+  return { prs: output.prs };
+}

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { JulesSession } from "../types.js";
+import { runCommand } from "../../lib/shell.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-cli", ["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}`);
+  }
+
+  return {
+    id: input.sessionId.replace("sessions/", ""),
+    status: "FAILED",
+    createdAt: new Date(),
+  };
+}

package/src/tools/jules/create-session.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createJulesSessionHandler } from "./create-session.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+
+vi.mock("../../lib/shell.js", () => ({
+  runCommand: vi.fn(),
+}));
+
+describe("createJulesSessionHandler", () => {
+  beforeEach(() => {
+    setupTestEnv();
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify({
+        status: "success",
+        name: "sessions/1234567890",
+        state: "IN_PROGRESS",
+        createTime: new Date().toISOString(),
+      }),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 10,
+      command: "td-cli agent dispatch"
+    });
+  });
+
+  afterEach(() => {
+    teardownTestEnv();
+    vi.clearAllMocks();
+  });
+
+  it("should create a session with just task", async () => {
+    const result = await createJulesSessionHandler({ task: "do work" });
+    expect(result.id).toBe("1234567890");
+    expect(result.status).toBe("IN_PROGRESS");
+    expect(result.createdAt).toBeInstanceOf(Date);
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "agent", "dispatch", "main", "do work"
+    ]);
+  });
+
+  it("should create a session with specific branch", async () => {
+    const result = await createJulesSessionHandler({ task: "do work", branch: "feature-x" });
+    expect(result.id).toBe("1234567890");
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "agent", "dispatch", "feature-x", "do work"
+    ]);
+  });
+
+  it("should create a session with PR number", async () => {
+    vi.mocked(shell.runCommand).mockImplementation(async (cmd, args) => {
+      if (args[1] === "view") {
+        return {
+          stdout: JSON.stringify({ status: "success", pr: { headRefName: "pr-branch" } }),
+          stderr: "",
+          exitCode: 0,
+          durationMs: 10,
+          command: "td-cli gh view"
+        };
+      }
+      return {
+        stdout: JSON.stringify({
+          status: "success",
+          name: "sessions/1234567890",
+          state: "IN_PROGRESS",
+          createTime: new Date().toISOString(),
+        }),
+        stderr: "",
+        exitCode: 0,
+        durationMs: 10,
+        command: "td-cli agent dispatch"
+      };
+    });
+
+    const result = await createJulesSessionHandler({ task: "do work", pr: 42 });
+    expect(result.id).toBe("1234567890");
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "gh", "view", "42"
+    ]);
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "agent", "dispatch", "pr-branch", "do work"
+    ]);
+  });
+
+  it("should throw error if PR view fails", async () => {
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify({ status: "error", message: "PR not found" }),
+      stderr: "Original error",
+      exitCode: 1,
+      durationMs: 10,
+      command: "td-cli gh view"
+    });
+
+    await expect(createJulesSessionHandler({ task: "do work", pr: 999 }))
+      .rejects.toThrow("td-cli returned error: PR not found");
+  });
+
+  it("should throw descriptive error if PR JSON is invalid", async () => {
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: "invalid json",
+      stderr: "",
+      exitCode: 0,
+      durationMs: 10,
+      command: "td-cli gh view"
+    });
+
+    await expect(createJulesSessionHandler({ task: "do work", pr: 42 }))
+      .rejects.toThrow("td-cli returned non-JSON output with exit code 0: invalid json");
+  });
+});

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

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runTDCli } from "../../lib/td-cli.js";
+import { parseJulesSession } from "./shared.js";
+
+export const CreateJulesSessionInputSchema = z.object({
+  task: z.string(),
+  branch: z.string().optional(),
+  pr: z.number().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()]);
+    branch = prData.pr.headRefName;
+  }
+
+  if (!branch) {
+      branch = process.env.DEFAULT_BASE_BRANCH || "main";
+  }
+
+  const output = await runTDCli(["agent", "dispatch", branch, input.task]);
+  return parseJulesSession(output.session || output);
+}

package/src/tools/jules/get-messages.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { getJulesMessagesHandler } from "./get-messages.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+
+vi.mock("../../lib/shell.js", () => ({
+  runCommand: vi.fn(),
+}));
+
+describe("getJulesMessagesHandler", () => {
+  beforeEach(() => {
+    setupTestEnv();
+  });
+
+  afterEach(() => {
+    teardownTestEnv();
+    vi.clearAllMocks();
+  });
+
+  it("should return messages from td-cli", async () => {
+    const mockMessages = [
+      {
+        role: "user",
+        content: "Hello Jules",
+        time: new Date().toISOString(),
+      },
+      {
+        role: "jules",
+        content: "Applying fixes...",
+        time: new Date().toISOString(),
+      },
+    ];
+
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify({ status: "success", messages: mockMessages }),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 0,
+      command: "td-cli agent messages"
+    });
+
+    const result = await getJulesMessagesHandler({ sessionId: "123" });
+    expect(result.id).toBe("123");
+    expect(result.messages.length).toBe(2);
+    expect(result.messages[0].role).toBe("user");
+    expect(result.messages[0].content).toBe("Hello Jules");
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "agent", "messages", "123"
+    ]);
+  });
+});

package/src/tools/jules/get-messages.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runCommand } from "../../lib/shell.js";
+
+export const GetJulesMessagesInputSchema = z.object({
+  sessionId: z.string(),
+});
+
+export async function getJulesMessagesHandler(input: z.infer<typeof GetJulesMessagesInputSchema>) {
+  const result = await runCommand("td-cli", ["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}`);
+  }
+
+  return {
+    id: input.sessionId.replace("sessions/", ""),
+    messages: output.messages,
+  };
+}

package/src/tools/jules/get-pr.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { getJulesPullRequestHandler } from "./get-pr.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+
+vi.mock("../../lib/shell.js", () => ({
+  runCommand: vi.fn(),
+}));
+
+describe("getJulesPullRequestHandler", () => {
+  beforeEach(() => {
+    setupTestEnv();
+  });
+
+  afterEach(() => {
+    teardownTestEnv();
+    vi.clearAllMocks();
+  });
+
+  it("should get PR from td-cli", async () => {
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify({
+        status: "success",
+        session: {
+          name: "sessions/123",
+          outputs: [{ pullRequest: { url: "https://github.com/pr/1" } }]
+        }
+      }),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 0,
+      command: "td-cli agent get-session"
+    });
+
+    const result = await getJulesPullRequestHandler({ sessionId: "123" });
+    expect(result.id).toBe("123");
+    expect(result.pullRequestUrl).toBe("https://github.com/pr/1");
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "agent", "get-session", "123"
+    ]);
+  });
+});

package/src/tools/jules/get-pr.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { runTDCli } from "../../lib/td-cli.js";
+import { parseJulesSession } from "./shared.js";
+
+export const GetJulesPullRequestInputSchema = z.object({
+  sessionId: z.string(),
+});
+
+export async function getJulesPullRequestHandler(input: z.infer<typeof GetJulesPullRequestInputSchema>) {
+  const output = await runTDCli(["agent", "get-session", input.sessionId]);
+  const session = parseJulesSession(output.session);
+
+  return {
+    id: session.id,
+    pullRequestUrl: session.pullRequestUrl,
+  };
+}

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { runTDCli } from "../../lib/td-cli.js";
+import { parseJulesSession } from "./shared.js";
+
+export const GetJulesSessionInputSchema = z.object({
+  sessionId: z.string(),
+});
+
+export async function getJulesSessionHandler(input: z.infer<typeof GetJulesSessionInputSchema>) {
+  const output = await runTDCli(["agent", "get-session", input.sessionId]);
+  return parseJulesSession(output.session);
+}

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

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { JulesSession, JulesStatus } from "../types.js";
+import { runCommand } from "../../lib/shell.js";
+
+export const ListJulesSessionsInputSchema = z.object({
+  pageSize: z.number().optional(),
+  pageToken: z.string().optional(),
+});
+
+export async function listJulesSessionsHandler(input: z.infer<typeof ListJulesSessionsInputSchema>): Promise<JulesSession[]> {
+  const result = await runCommand("td-cli", ["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 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,
+    };
+  });
+}

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

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { sendJulesMessageHandler } from "./send-message.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+
+vi.mock("../../lib/shell.js", () => ({
+  runCommand: vi.fn(),
+}));
+
+describe("sendJulesMessageHandler", () => {
+  beforeEach(() => {
+    setupTestEnv();
+  });
+
+  afterEach(() => {
+    teardownTestEnv();
+    vi.clearAllMocks();
+  });
+
+  it("should send a message via td-cli", async () => {
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify({ status: "success", message: "Message sent successfully" }),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 0,
+      command: "td-cli agent send"
+    });
+
+    const result = await sendJulesMessageHandler({ sessionId: "123", message: "hi" });
+    expect(result.id).toBe("123");
+    expect(result.status).toBe("success");
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "agent", "send", "123", "hi"
+    ]);
+  });
+
+  it("should support batch message sending", async () => {
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify({
+        status: "success",
+        message: "Batch send completed. 2/2 successful.",
+        results: [
+          { sessionId: "s1", status: "success" },
+          { sessionId: "s2", status: "success" }
+        ]
+      }),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 0,
+      command: "td-cli agent send"
+    });
+
+    const result = await sendJulesMessageHandler({
+      sessionId: ["sessions/s1", "sessions/s2"],
+      message: "hi batch"
+    });
+
+    expect(result.id).toEqual(["s1", "s2"]);
+    expect(result.status).toBe("success");
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "agent", "send", "sessions/s1,sessions/s2", "hi batch"
+    ]);
+  });
+});

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { runCommand } from "../../lib/shell.js";
+
+export const SendJulesMessageInputSchema = z.object({
+  sessionId: z.union([z.string(), z.array(z.string())]),
+  message: z.string(),
+});
+
+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-cli", ["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}`);
+  }
+
+  return {
+    id: Array.isArray(input.sessionId) ? input.sessionId.map(id => id.replace("sessions/", "")) : input.sessionId.replace("sessions/", ""),
+    status: "success",
+    message: "Message sent successfully",
+  };
+}

package/src/tools/jules/shared.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/trigger-feedback.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { triggerJulesFeedbackHandler } from "./trigger-feedback.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+
+vi.mock("../../lib/shell.js", () => ({
+  runCommand: vi.fn(),
+}));
+
+describe("triggerJulesFeedbackHandler", () => {
+  beforeEach(() => {
+    setupTestEnv();
+  });
+
+  afterEach(() => {
+    teardownTestEnv();
+    vi.clearAllMocks();
+  });
+
+  it("should return success output from td-cli", async () => {
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify({ status: "success", feedback: "All checks passed successfully. You may proceed." }),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 0,
+      command: "td-cli agent trigger-feedback"
+    });
+
+    const result = await triggerJulesFeedbackHandler({ sessionId: "123" });
+    expect(result.status).toBe("success");
+    expect(result.feedback).toBe("All checks passed successfully. You may proceed.");
+
+    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+      "agent", "trigger-feedback", "123"
+    ]);
+  });
+
+  it("should throw error if td-cli returns error", async () => {
+    vi.mocked(shell.runCommand).mockResolvedValue({
+      stdout: JSON.stringify({ status: "error", message: "Session not found" }),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 0,
+      command: "td-cli agent trigger-feedback"
+    });
+
+    await expect(triggerJulesFeedbackHandler({ sessionId: "123" }))
+      .rejects.toThrow("Failed to trigger feedback: Session not found");
+  });
+});

package/src/tools/jules/trigger-feedback.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { runCommand } from "../../lib/shell.js";
+
+export const TriggerJulesFeedbackInputSchema = z.object({
+  sessionId: z.string(),
+});
+
+export async function triggerJulesFeedbackHandler(input: z.infer<typeof TriggerJulesFeedbackInputSchema>) {
+  const result = await runCommand("td-cli", ["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;
+}

package/src/tools/repo.commit_patch.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+
+export const CommitPatchInputSchema = z.object({
+  worktreePath: z.string(),
+  message: z.string(),
+  allowedFiles: z.array(z.string()),
+  writeMode: z.boolean().optional().default(false),
+});
+
+export async function commitPatchHandler(args: z.infer<typeof CommitPatchInputSchema>) {
+  if (!args.writeMode) {
+    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));
+  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 });
+
+  if (commitResult.exitCode !== 0) {
+    throw new Error(`Failed to commit: ${commitResult.stderr}`);
+  }
+
+  const shaResult = await runCommand("git", ["rev-parse", "HEAD"], { cwd: args.worktreePath });
+
+  return {
+    success: true,
+    commitSha: shaResult.stdout.trim(),
+    changedFiles
+  };
+}