@arii/boomtick-mcp 0.4.1 → 0.5.0

package/src/tools/github.create_issue.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
 import { sanitizeError } from "../lib/error_utils.js";
 import { CreateIssueInputSchema, CreateIssueResponseSchema } from "./contract.js";
 
@@ -7,11 +8,12 @@ export { CreateIssueInputSchema };
 
 export async function createIssueHandler(args: z.input<typeof CreateIssueInputSchema>) {
   const params = CreateIssueInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
 
   const cmdArgs = ["gh", "create-issue", "--title", params.title];
   if (params.body) cmdArgs.push("--body", params.body);
   if (params.file) cmdArgs.push("--file", params.file);
-  if (params.repo) cmdArgs.push("--repo", params.repo);
+  cmdArgs.push("--repo", targetRepo);
 
   const result = await runCommand("td-cli", cmdArgs);
 

package/src/tools/github.create_pull_request.ts

@@ -1,11 +1,13 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
 import { CreatePullRequestInputSchema } from "./contract.js";
 
 export { CreatePullRequestInputSchema };
 
 export async function createPullRequestHandler(args: z.input<typeof CreatePullRequestInputSchema>) {
   const params = CreatePullRequestInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
 
   const tdArgs = [
     "gh",
@@ -13,17 +15,14 @@ export async function createPullRequestHandler(args: z.input<typeof CreatePullRe
     "--title", params.title,
     "--body", params.body,
     "--head", params.head,
-    "--base", params.base
+    "--base", params.base,
+    "--repo", targetRepo
   ];
 
   if (params.draft) {
     tdArgs.push("--draft");
   }
 
-  if (params.repo) {
-    tdArgs.push("--repo", params.repo);
-  }
-
   const result = await runCommand("td-cli", tdArgs);
 
   if (result.exitCode !== 0) {

package/src/tools/github.get_merge_conflict_files.ts

@@ -1,31 +1,21 @@
 import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
+import { getMergeConflictFiles } from "../lib/git.js";
 
 export const GetMergeConflictFilesInputSchema = z.object({
-  prNumber: z.number(),
+  prNumber: z.number().optional(),
   baseBranch: z.string().optional().default("main"),
+  headRef: z.string().optional().default("HEAD"),
 });
 
 export async function getMergeConflictFilesHandler(args: z.infer<typeof GetMergeConflictFilesInputSchema>) {
-  const result = await runCommand("td-cli", [
-    "gh", "merge-conflicts", args.prNumber.toString(),
-    "--base", args.baseBranch || "main"
-  ]);
-
-  if (result.exitCode !== 0) {
-    throw new Error(`Failed to get merge conflicts: ${result.stderr}`);
-  }
-
-  const output = JSON.parse(result.stdout);
-  if (output.status === "error") {
-    throw new Error(`Failed to get merge conflicts: ${output.message}`);
-  }
+  const baseBranch = args.baseBranch || "main";
+  const headRef = args.headRef || "HEAD";
+  const conflictFiles = await getMergeConflictFiles(baseBranch, headRef);
 
   return {
-    prNumber: output.prNumber,
-    baseBranch: output.baseBranch,
-    headRef: output.headRef,
-    conflictFiles: output.conflictFiles,
-    commandLog: output.commandLog
+    prNumber: args.prNumber,
+    baseBranch,
+    headRef,
+    conflictFiles,
   };
 }

package/src/tools/github.get_pr.ts

@@ -1,15 +1,18 @@
 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 GetPrInputSchema = z.object({
   prNumber: z.number().describe("The number of the PR to view."),
+  repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
 });
 
 export async function getPrHandler(args: z.infer<typeof GetPrInputSchema>) {
   const params = GetPrInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
 
-  const result = await runCommand("td-cli", ["gh", "view", params.prNumber.toString()]);
+  const result = await runCommand("td-cli", ["gh", "view", params.prNumber.toString(), "--repo", targetRepo]);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to get PR details: ${sanitizeError(result.stderr)}`);

package/src/tools/github.get_pr_commits.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
+import { sanitizeError } from "../lib/error_utils.js";
+
+const GetPrCommitsInputSchema = z.object({
+  prNumber: z.number().describe("The number of the PR to list commits for."),
+  repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
+});
+
+export async function getPrCommitsHandler(args: z.infer<typeof GetPrCommitsInputSchema>) {
+  const params = GetPrCommitsInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
+
+  const result = await runCommand("td-cli", ["gh", "list-pr-commits", "--pr-number", params.prNumber.toString(), "--repo", targetRepo]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to list PR commits: ${sanitizeError(result.stderr)}`);
+  }
+
+  const output = JSON.parse(result.stdout);
+  if (output.status === "error") {
+    throw new Error(`Failed to list PR commits: ${output.message}`);
+  }
+
+  return { commits: output.commits };
+}

package/src/tools/github.get_pr_diff.ts

@@ -1,13 +1,18 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
 
 export const GetPrDiffInputSchema = z.object({
-  prNumber: z.number(),
+  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)."),
 });
 
 export async function getPrDiffHandler(args: z.infer<typeof GetPrDiffInputSchema>) {
+  const params = GetPrDiffInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
+
   const result = await runCommand("td-cli", [
-    "gh", "pr-diff", args.prNumber.toString()
+    "gh", "pr-diff", params.prNumber.toString(), "--repo", targetRepo
   ]);
 
   if (result.exitCode !== 0) {

package/src/tools/github.get_pr_reviews.test.ts

@@ -0,0 +1,110 @@
+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/src/tools/github.get_pr_reviews.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
+import { sanitizeError } from "../lib/error_utils.js";
+
+const GetPrReviewsInputSchema = z.object({
+  prNumber: z.number().describe("The number of the PR to view reviews for."),
+  repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
+});
+
+export async function getPrReviewsHandler(args: z.infer<typeof GetPrReviewsInputSchema>) {
+  const params = GetPrReviewsInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
+
+  const result = await runCommand("td-cli", ["gh", "read-pr-reviews", "--pr-number", params.prNumber.toString(), "--repo", targetRepo]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to read PR reviews: ${sanitizeError(result.stderr)}`);
+  }
+
+  const output = JSON.parse(result.stdout);
+  if (output.status === "error") {
+    throw new Error(`Failed to read PR reviews: ${output.message}`);
+  }
+
+  return { reviews: output.reviews, reviewCount: output.review_count };
+}

package/src/tools/github.issue_comment.ts

@@ -1,10 +1,12 @@
 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({
@@ -15,8 +17,13 @@ const IssueCommentOutputSchema = z.object({
 
 export async function issueCommentHandler(args: z.infer<typeof IssueCommentInputSchema>) {
   const params = IssueCommentInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
 
-  const result = await runCommand("td-cli", ["gh", "issue-comment", params.issueNumber.toString(), "--body", params.body]);
+  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/src/tools/github.issue_update.ts

@@ -1,12 +1,14 @@
 import { z } from "zod";
 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: any) {
+export async function issueUpdateHandler(args: z.infer<typeof IssueUpdateInputSchema>) {
   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);
@@ -15,6 +17,7 @@ export async function issueUpdateHandler(args: any) {
   if (params.addLabels && params.addLabels.length > 0) cmdArgs.push("--add-labels", params.addLabels.join(","));
   if (params.removeLabels && params.removeLabels.length > 0) 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);
 

package/src/tools/github.issue_view.ts

@@ -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 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({
@@ -19,8 +21,9 @@ const IssueViewOutputSchema = z.object({
 
 export async function issueViewHandler(args: z.infer<typeof IssueViewInputSchema>) {
   const params = IssueViewInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
 
-  const result = await runCommand("td-cli", ["gh", "issue-view", params.issueNumber.toString()]);
+  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/src/tools/github.search_open_prs.ts

@@ -1,20 +1,24 @@
 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: z.infer<typeof SearchOpenPrsInputSchema>) {
   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) {

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

@@ -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(),

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

@@ -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/src/tools/jules/get-session.ts

@@ -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/src/tools/jules/shared.ts

@@ -1,4 +1,39 @@
 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-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: any): JulesSession {
   const name = data.name || "";

package/src/tools/repo.commit_patch.ts

@@ -1,21 +1,45 @@
 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: z.infer<typeof CommitPatchInputSchema>) {
-  if (!args.writeMode) {
+export type CommitPatchInput = z.input<typeof CommitPatchInputSchema>;
+
+export async function commitPatchHandler(args: CommitPatchInput) {
+  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(", ")}`);
   }
@@ -24,18 +48,18 @@ export async function commitPatchHandler(args: z.infer<typeof CommitPatchInputSc
     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/src/tools/repo.get_changed_files.ts

@@ -1,5 +1,5 @@
 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"),
@@ -7,20 +7,6 @@ export const GetChangedFilesInputSchema = z.object({
 });
 
 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 };
-  });
-
+  const files = await getChangedFiles(args.base || "main", args.head || "HEAD");
   return { files };
 }

package/src/tools/repo.get_workflow_runs.ts

@@ -0,0 +1,36 @@
+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: z.infer<typeof GetWorkflowRunsInputSchema>) {
+  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/src/tools/repo.logs.ts

@@ -1,9 +1,10 @@
 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: z.infer<typeof RepoLogsInputSchema>) {
@@ -12,6 +13,9 @@ export async function repoLogsHandler(args: z.infer<typeof RepoLogsInputSchema>)
   if (args.grep) {
     params.push("--grep", args.grep);
   }
+  if (args.repo) {
+    params.push("--repo", args.repo);
+  }
 
   const output = await runTDCli(params);
 

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

@@ -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", () => {