@arii/boomtick-mcp 0.4.1 → 0.4.2

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/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.run_playwright.ts

@@ -4,18 +4,25 @@ import { runCommand } from "../lib/shell.js";
 export const RunPlaywrightInputSchema = z.object({
   grep: z.string().optional(),
   worktreePath: z.string().optional(),
+  timeoutSeconds: z.number().optional().default(180),
 });
 
-export async function runPlaywrightHandler(args: z.infer<typeof RunPlaywrightInputSchema>) {
+export type RunPlaywrightInput = z.input<typeof RunPlaywrightInputSchema>;
+
+export async function runPlaywrightHandler(args: RunPlaywrightInput) {
+  const parsed = RunPlaywrightInputSchema.parse(args || {});
   const tdArgs = ["repo", "run-playwright"];
-  if (args.grep) {
-    tdArgs.push("--grep", args.grep);
+  if (parsed.grep) {
+    tdArgs.push("--grep", parsed.grep);
   }
-  if (args.worktreePath) {
-    tdArgs.push("--worktree", args.worktreePath);
+  if (parsed.worktreePath) {
+    tdArgs.push("--worktree", parsed.worktreePath);
   }
 
-  const result = await runCommand("td-cli", tdArgs);
+  const result = await runCommand("td-cli", tdArgs, {
+    cwd: parsed.worktreePath,
+    timeout: parsed.timeoutSeconds * 1000,
+  });
 
   if (result.exitCode !== 0) {
     // Playwright might exit with non-zero if tests fail, but our td-cli should ideally handle it

package/src/tools/repo.run_tests.ts

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