@arii/boomtick-mcp 0.6.2 → 0.7.1

package/src/tools/github.get_merge_conflict_files.ts

@@ -1,16 +1,25 @@
 import { z } from "zod";
-import { getMergeConflictFiles } from "../lib/git.js";
+import { getMergeConflictFiles, resolveRepoPath } from "../lib/git.js";
 
 export const GetMergeConflictFilesInputSchema = z.object({
   prNumber: z.number().optional(),
   baseBranch: z.string().optional().default("main"),
   headRef: z.string().optional().default("HEAD"),
+  repo: z.string().optional().describe("Target GitHub repository override."),
+  path: z.string().optional().describe("Local filesystem path to target repository root."),
+  repoPath: z.string().optional().describe("Alias for path to target repository root."),
 });
 
 export async function getMergeConflictFilesHandler(args: z.infer<typeof GetMergeConflictFilesInputSchema>) {
   const baseBranch = args.baseBranch || "main";
   const headRef = args.headRef || "HEAD";
-  const conflictFiles = await getMergeConflictFiles(baseBranch, headRef);
+  const targetCwd = resolveRepoPath({
+    path: args.path,
+    repoPath: args.repoPath,
+    repo: args.repo,
+  });
+
+  const conflictFiles = await getMergeConflictFiles(baseBranch, headRef, targetCwd);
 
   const hasConflicts = conflictFiles.length > 0;
 

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/repo.create_branch.test.ts

@@ -21,13 +21,22 @@ describe("repo.create_branch", () => {
 
     const result = await createBranchHandler(args);
 
-    expect(shell.runCommand).toHaveBeenCalledWith("git", ["fetch", "origin", "main"]);
-    expect(shell.runCommand).toHaveBeenCalledWith("git", ["checkout", "-b", "new-feature", "origin/main"]);
-    expect(result).toEqual({
+    expect(shell.runCommand).toHaveBeenCalledWith(
+      "git",
+      ["fetch", "origin", "main"],
+      { cwd: expect.any(String) }
+    );
+    expect(shell.runCommand).toHaveBeenCalledWith(
+      "git",
+      ["checkout", "-b", "new-feature", "origin/main"],
+      { cwd: expect.any(String) }
+    );
+    expect(result).toMatchObject({
       success: true,
       branchName: "new-feature",
       baseBranch: "main",
     });
+    expect(result.path).toBeDefined();
   });
 
   it("should use default base branch 'main' if not provided", async () => {
@@ -39,8 +48,67 @@ describe("repo.create_branch", () => {
 
     const result = await createBranchHandler(args);
 
-    expect(shell.runCommand).toHaveBeenCalledWith("git", ["fetch", "origin", "main"]);
-    expect(shell.runCommand).toHaveBeenCalledWith("git", ["checkout", "-b", "another-feature", "origin/main"]);
+    expect(shell.runCommand).toHaveBeenCalledWith(
+      "git",
+      ["fetch", "origin", "main"],
+      { cwd: expect.any(String) }
+    );
+    expect(shell.runCommand).toHaveBeenCalledWith(
+      "git",
+      ["checkout", "-b", "another-feature", "origin/main"],
+      { cwd: expect.any(String) }
+    );
+    expect(result.success).toBe(true);
+  });
+
+  it("should create branch in specified target workspace path", async () => {
+    const args: CreateBranchInput = {
+      branchName: "custom-path-feature",
+      baseBranch: "main",
+      path: "/home/ari/tech-dancer",
+    };
+
+    (shell.runCommand as any).mockResolvedValue({ exitCode: 0, stdout: "", stderr: "" });
+
+    const result = await createBranchHandler(args);
+
+    expect(shell.runCommand).toHaveBeenCalledWith(
+      "git",
+      ["fetch", "origin", "main"],
+      { cwd: "/home/ari/tech-dancer" }
+    );
+    expect(shell.runCommand).toHaveBeenCalledWith(
+      "git",
+      ["checkout", "-b", "custom-path-feature", "origin/main"],
+      { cwd: "/home/ari/tech-dancer" }
+    );
+    expect(result).toEqual({
+      success: true,
+      branchName: "custom-path-feature",
+      baseBranch: "main",
+      path: "/home/ari/tech-dancer",
+    });
+  });
+
+  it("should include repo field when repo override is specified", async () => {
+    const args: CreateBranchInput = {
+      branchName: "repo-feature",
+      baseBranch: "main",
+      repo: "arii/tech-dancer",
+      path: "/home/ari/tech-dancer",
+    };
+
+    (shell.runCommand as any).mockResolvedValue({ exitCode: 0, stdout: "", stderr: "" });
+
+    const result = await createBranchHandler(args);
+
+    expect(result).toEqual({
+      success: true,
+      branchName: "repo-feature",
+      baseBranch: "main",
+      path: "/home/ari/tech-dancer",
+      repo: "arii/tech-dancer",
+    });
   });
 
   it("should throw error if git command fails", async () => {

package/src/tools/repo.create_branch.ts

@@ -1,29 +1,55 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
+import { resolveRepoPath } from "../lib/git.js";
 
 export const CreateBranchInputSchema = z.object({
   branchName: z.string(),
   baseBranch: z.string().optional().default("main"),
+  repo: z.string().optional().describe("Target repository override (e.g. org/repo or repo)."),
+  path: z.string().optional().describe("Local filesystem path to target repository root."),
+  repoPath: z.string().optional().describe("Alias for path to target repository root."),
 });
 
 export type CreateBranchInput = z.input<typeof CreateBranchInputSchema>;
 
 export async function createBranchHandler(args: CreateBranchInput) {
   const params = CreateBranchInputSchema.parse(args);
+  const targetCwd = resolveRepoPath({
+    path: params.path,
+    repoPath: params.repoPath,
+    repo: params.repo,
+  });
 
   // Ensure latest base branch
-  await runCommand("git", ["fetch", "origin", params.baseBranch]);
+  await runCommand("git", ["fetch", "origin", params.baseBranch], { cwd: targetCwd });
 
   // Create branch from origin base branch
-  const result = await runCommand("git", ["checkout", "-b", params.branchName, `origin/${params.baseBranch}`]);
+  const result = await runCommand(
+    "git",
+    ["checkout", "-b", params.branchName, `origin/${params.baseBranch}`],
+    { cwd: targetCwd }
+  );
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to create branch ${params.branchName}: ${result.stderr}`);
   }
 
-  return {
+  const response: {
+    success: boolean;
+    branchName: string;
+    baseBranch: string;
+    path: string;
+    repo?: string;
+  } = {
     success: true,
     branchName: params.branchName,
-    baseBranch: params.baseBranch
+    baseBranch: params.baseBranch,
+    path: targetCwd,
   };
+
+  if (params.repo) {
+    response.repo = params.repo;
+  }
+
+  return response;
 }

package/src/tools/repo.create_repair_branch.ts

@@ -1,23 +1,38 @@
 import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
-import { createWorktree } from "../lib/git.js";
+import { createWorktree, resolveRepoPath } from "../lib/git.js";
 
 export const CreateRepairBranchInputSchema = z.object({
   prNumber: z.number(),
   repairBranchName: z.string().optional(),
   writeMode: z.boolean().optional().default(false),
+  repo: z.string().optional().describe("Target repository override (e.g. org/repo or repo)."),
+  path: z.string().optional().describe("Local filesystem path to target repository root."),
+  repoPath: z.string().optional().describe("Alias for path to target repository root."),
 });
 
 export async function createRepairBranchHandler(args: z.infer<typeof CreateRepairBranchInputSchema>) {
   if (!args.writeMode) {
     throw new Error("writeMode must be true to create a repair branch.");
   }
-  const prResult = await runCommand("gh", [
+
+  const targetCwd = resolveRepoPath({
+    path: args.path,
+    repoPath: args.repoPath,
+    repo: args.repo,
+  });
+
+  const ghArgs = [
     "pr",
     "view",
     args.prNumber.toString(),
     "--json", "headRefName,baseRefName,title"
-  ]);
+  ];
+  if (args.repo) {
+    ghArgs.push("--repo", args.repo);
+  }
+
+  const prResult = await runCommand("gh", ghArgs, { cwd: targetCwd });
 
   if (prResult.exitCode !== 0) {
     throw new Error(`Failed to get PR info: ${prResult.stderr}`);
@@ -28,20 +43,27 @@ export async function createRepairBranchHandler(args: z.infer<typeof CreateRepai
   const sanitizedTitle = title.toLowerCase().replace(/[^a-z0-9]/g, "-").substring(0, 30);
   const repairBranch = args.repairBranchName || `agent/repair-pr-${args.prNumber}-${sanitizedTitle}`;
 
-  // Ensure latest
-  await runCommand("git", ["fetch", "origin", headRefName]);
-  await runCommand("git", ["fetch", "origin", baseRefName]);
+  // Ensure latest in target repo
+  await runCommand("git", ["fetch", "origin", headRefName], { cwd: targetCwd });
+  await runCommand("git", ["fetch", "origin", baseRefName], { cwd: targetCwd });
 
-  const worktreePath = await createWorktree(`origin/${headRefName}`, args.prNumber);
+  const worktreePath = await createWorktree(`origin/${headRefName}`, args.prNumber, targetCwd);
 
   // Create the actual repair branch in the worktree
   await runCommand("git", ["checkout", "-b", repairBranch], { cwd: worktreePath });
 
-  return {
+  const response: Record<string, unknown> = {
     prNumber: args.prNumber,
     originalBranch: headRefName,
     repairBranch,
     baseBranch: baseRefName,
-    worktreePath
+    worktreePath,
+    path: targetCwd,
   };
+
+  if (args.repo) {
+    response.repo = args.repo;
+  }
+
+  return response;
 }

package/src/tools/repo.get_changed_files.ts

@@ -1,12 +1,20 @@
 import { z } from "zod";
-import { getChangedFiles } from "../lib/git.js";
+import { getChangedFiles, resolveRepoPath } from "../lib/git.js";
 
 export const GetChangedFilesInputSchema = z.object({
   base: z.string().optional().default("main"),
   head: z.string().optional().default("HEAD"),
+  repo: z.string().optional().describe("Target GitHub repository override."),
+  path: z.string().optional().describe("Local filesystem path to target repository root."),
+  repoPath: z.string().optional().describe("Alias for path to target repository root."),
 });
 
 export async function getChangedFilesHandler(args: z.infer<typeof GetChangedFilesInputSchema>) {
-  const files = await getChangedFiles(args.base || "main", args.head || "HEAD");
+  const targetCwd = resolveRepoPath({
+    path: args.path,
+    repoPath: args.repoPath,
+    repo: args.repo,
+  });
+  const files = await getChangedFiles(args.base || "main", args.head || "HEAD", targetCwd);
   return { files };
 }

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");
+  });
+});

package/src/tools/repo.multi_exec.ts

@@ -0,0 +1,23 @@
+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: z.input<typeof MultiExecInputSchema>) {
+  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/src/tools/repo.read_agent_context.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { loadStandaloneAgentContext } from "./repo.read_agent_context.js";
+import { loadStandaloneAgentContext, readAgentContextHandler } from "./repo.read_agent_context.js";
 
 describe("Standalone Agent Context Loader", () => {
   it("should load agent context without submodule references", () => {
@@ -8,4 +8,38 @@ describe("Standalone Agent Context Loader", () => {
     expect(context).toHaveProperty("gitCommit");
     expect(context).not.toHaveProperty("submodules");
   });
+
+  it("should handle readAgentContextHandler with default workspace", async () => {
+    const res = await readAgentContextHandler({});
+    expect(res.status).toBe("success");
+    expect(res).toHaveProperty("packageName");
+    expect(res).toHaveProperty("gitCommit");
+  });
+
+  it("readAgentContextHandler should accept optional repoPath argument", async () => {
+    const res = await readAgentContextHandler({ repoPath: process.cwd() });
+    expect(res).toHaveProperty("status", "success");
+    expect(res).toHaveProperty("packageName");
+    expect(res).toHaveProperty("gitCommit");
+  });
+
+  it("readAgentContextHandler should accept path argument", async () => {
+    const res = await readAgentContextHandler({ path: process.cwd() });
+    expect(res).toHaveProperty("status", "success");
+    expect(res).toHaveProperty("packageName");
+  });
+
+  it("readAgentContextHandler should accept repo argument", async () => {
+    const res = await readAgentContextHandler({ repo: "arii/tech-dancer" });
+    expect(res).toHaveProperty("status", "success");
+    expect(res).toHaveProperty("repo", "arii/tech-dancer");
+  });
+
+  it("should handle multi-repo context querying when all: true is passed", async () => {
+    const res = await readAgentContextHandler({ all: true });
+    expect(res.status).toBe("success");
+    expect(res.ecosystem).toBe(true);
+    expect(Array.isArray(res.repos)).toBe(true);
+    expect(res.repos.length).toBeGreaterThan(0);
+  });
 });

package/src/tools/repo.read_agent_context.ts

@@ -3,6 +3,7 @@ import { config } from "../config.js";
 import { execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
+import { runTDCli } from "./jules/shared.js";
 
 export interface AgentContext {
   packageName: string;
@@ -36,14 +37,78 @@ export const loadStandaloneAgentContext = (repoRoot: string = process.cwd()): Ag
   };
 };
 
-export const ReadAgentContextInputSchema = z.object({});
+export const ReadAgentContextInputSchema = z.object({
+  path: z.string().optional().describe("Local filesystem path to target repository root"),
+  repoPath: z.string().optional().describe("Alias for path to target repository root"),
+  repo: z.string().optional().describe("Repository name override (e.g. arii/portfolio or portfolio)"),
+  repos: z.array(z.string()).optional().describe("List of repository names to fetch context for"),
+  all: z.boolean().optional().describe("Whether to fetch context across all discovered ecosystem repositories"),
+});
 
-export async function readAgentContextHandler(_args: z.infer<typeof ReadAgentContextInputSchema>) {
-  const context = loadStandaloneAgentContext(config.repoPath);
+export async function readAgentContextHandler(args: z.infer<typeof ReadAgentContextInputSchema>) {
+  // 1. Ecosystem / Multi-repo request
+  if (args.all || (args.repos && args.repos.length > 0)) {
+    const cliArgs = ["multi-repo", "status"];
+    if (args.repos) {
+      for (const r of args.repos) {
+        cliArgs.push("-r", r);
+      }
+    }
+    const output = await runTDCli(cliArgs, "fetch multi-repo context");
+    return {
+      status: "success",
+      ecosystem: true,
+      repos: output.repos ?? [],
+      total: output.total ?? (output.repos?.length ?? 0)
+    };
+  }
+
+  // 2. Specific repository name override
+  if (args.repo) {
+    let matchedPath: string | undefined;
+    try {
+      const output = await runTDCli(["multi-repo", "status", "-r", args.repo], "find target repository");
+      const matched = output.repos?.[0];
+      if (matched?.path) {
+        matchedPath = matched.path;
+      }
+    } catch {
+      // Fallback to directory inspection if CLI is unavailable or not in TD workspace
+    }
+
+    if (!matchedPath) {
+      const repoName = args.repo.includes("/") ? args.repo.split("/")[1] : args.repo;
+      const cwdParent = path.resolve(process.cwd(), "..", repoName);
+      const configParent = path.resolve(config.repoPath, "..", repoName);
+
+      if (fs.existsSync(cwdParent)) {
+        matchedPath = cwdParent;
+      } else if (fs.existsSync(configParent)) {
+        matchedPath = configParent;
+      }
+    }
+
+    if (matchedPath) {
+      const context = loadStandaloneAgentContext(matchedPath);
+      return {
+        status: "success",
+        repo: args.repo,
+        path: matchedPath,
+        ...context
+      };
+    }
+  }
+
+  // 3. Specific filesystem path
+  const targetPath = (args.path || args.repoPath) ? path.resolve(args.path || args.repoPath!) : config.repoPath;
+  const context = loadStandaloneAgentContext(targetPath);
   const result: any = {
     status: "success",
     ...context
   };
+  if (args?.repo) {
+    result.repo = args.repo;
+  }
   delete result.submodules;
   if (result.config) {
     delete result.config.submodules;