@arii/boomtick-mcp 0.6.2 → 0.7.1

package/dist/tools/github.get_merge_conflict_files.js

@@ -1,14 +1,22 @@
 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) {
     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;
     return {
         hasConflicts,

package/dist/tools/jules/create-session.js

@@ -4,16 +4,26 @@ 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) {
     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;
     }
     if (!branch) {
         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/dist/tools/jules/create-session.test.js

@@ -41,6 +41,13 @@ describe("createJulesSessionHandler", () => {
             "agent", "dispatch", "feature-x", "do work"
         ]);
     });
+    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/dist/tools/repo.create_branch.js

@@ -1,21 +1,35 @@
 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 async function createBranchHandler(args) {
     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: true,
         branchName: params.branchName,
-        baseBranch: params.baseBranch
+        baseBranch: params.baseBranch,
+        path: targetCwd,
     };
+    if (params.repo) {
+        response.repo = params.repo;
+    }
+    return response;
 }

package/dist/tools/repo.create_branch.test.js

@@ -15,13 +15,14 @@ describe("repo.create_branch", () => {
         };
         shell.runCommand.mockResolvedValue({ exitCode: 0, stdout: "", stderr: "" });
         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 () => {
         const args = {
@@ -29,8 +30,43 @@ describe("repo.create_branch", () => {
         };
         shell.runCommand.mockResolvedValue({ exitCode: 0, stdout: "", stderr: "" });
         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 = {
+            branchName: "custom-path-feature",
+            baseBranch: "main",
+            path: "/home/ari/tech-dancer",
+        };
+        shell.runCommand.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 = {
+            branchName: "repo-feature",
+            baseBranch: "main",
+            repo: "arii/tech-dancer",
+            path: "/home/ari/tech-dancer",
+        };
+        shell.runCommand.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 () => {
         const args = {

package/dist/tools/repo.create_repair_branch.js

@@ -1,38 +1,55 @@
 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) {
     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}`);
     }
     const { headRefName, baseRefName, title } = JSON.parse(prResult.stdout);
     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]);
-    const worktreePath = await createWorktree(`origin/${headRefName}`, args.prNumber);
+    // 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, targetCwd);
     // Create the actual repair branch in the worktree
     await runCommand("git", ["checkout", "-b", repairBranch], { cwd: worktreePath });
-    return {
+    const response = {
         prNumber: args.prNumber,
         originalBranch: headRefName,
         repairBranch,
         baseBranch: baseRefName,
-        worktreePath
+        worktreePath,
+        path: targetCwd,
     };
+    if (args.repo) {
+        response.repo = args.repo;
+    }
+    return response;
 }

package/dist/tools/repo.get_changed_files.js

@@ -1,10 +1,18 @@
 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) {
-    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/dist/tools/repo.multi_exec.js

@@ -0,0 +1,21 @@
+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) {
+    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/dist/tools/repo.multi_exec.test.js

@@ -0,0 +1,13 @@
+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/dist/tools/repo.read_agent_context.js

@@ -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 const loadStandaloneAgentContext = (repoRoot = process.cwd()) => {
     const configPath = path.join(repoRoot, "project_config.json");
     let projectConfig = {};
@@ -27,13 +28,74 @@ export const loadStandaloneAgentContext = (repoRoot = process.cwd()) => {
         config: projectConfig,
     };
 };
-export const ReadAgentContextInputSchema = z.object({});
-export async function readAgentContextHandler(_args) {
-    const context = loadStandaloneAgentContext(config.repoPath);
+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) {
+    // 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;
+        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 = {
         status: "success",
         ...context
     };
+    if (args?.repo) {
+        result.repo = args.repo;
+    }
     delete result.submodules;
     if (result.config) {
         delete result.config.submodules;

package/dist/tools/repo.read_agent_context.test.js

@@ -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", () => {
         const context = loadStandaloneAgentContext(process.cwd());
@@ -7,4 +7,33 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "Boomtick MCP Guide: PR Rescue + Merge Conflict Agent",
   "repository": {
     "type": "git",

package/src/config/dynamic.ts

@@ -1,14 +1,15 @@
 import { execSync } from "child_process";
+import { findRepoRoot } from "./repo.js";
 
 let cachedDynamicConfig: any = null;
 
-export function initializeConfig() {
+export function initializeConfig(targetCwd?: string) {
   if (cachedDynamicConfig !== null) {
     return cachedDynamicConfig;
   }
 
   try {
-    const cwd = process.env.BOOMTICK_REPO_PATH || process.cwd();
+    const cwd = findRepoRoot(targetCwd);
     const cmd = `td config view`;
     const output = execSync(cmd, {
       cwd,

package/src/config/repo.ts

@@ -4,12 +4,8 @@ import { fileURLToPath } from "url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-export function findRepoRoot(): string {
-  if (process.env.BOOMTICK_REPO_PATH) {
-    return process.env.BOOMTICK_REPO_PATH;
-  }
-
-  let current = process.cwd();
+export function findRepoRoot(startDir?: string): string {
+  let current = startDir || process.cwd();
   while (current !== path.parse(current).root) {
     if (
       fs.existsSync(path.join(current, "project_config.json")) ||
@@ -21,6 +17,10 @@ export function findRepoRoot(): string {
     current = path.dirname(current);
   }
 
+  if (process.env.BOOMTICK_REPO_PATH) {
+    return process.env.BOOMTICK_REPO_PATH;
+  }
+
   current = __dirname;
   while (current !== path.parse(current).root) {
     if (

package/src/config.test.ts

@@ -25,10 +25,11 @@ describe("config", () => {
       vi.mocked(execSync).mockReturnValue(JSON.stringify(mockConfig));
 
       const { initializeConfig } = await import("./config.js");
+      const { findRepoRoot } = await import("./config/repo.js");
       const result = initializeConfig();
 
       expect(execSync).toHaveBeenCalledWith("td config view", expect.objectContaining({
-        cwd: process.cwd()
+        cwd: findRepoRoot()
       }));
       expect(result).toEqual(mockConfig);
     });
@@ -133,10 +134,17 @@ describe("config", () => {
       expect(() => config.githubRepo).toThrow("GITHUB_REPO must be set via environment variable or project_config.json");
     });
 
-    it("should resolve repoPath from BOOMTICK_REPO_PATH or findRepoRoot fallback", async () => {
+    it("should resolve active workspace from process.cwd() over BOOMTICK_REPO_PATH when inside a repo", async () => {
       process.env.BOOMTICK_REPO_PATH = "/custom/repo/path";
       const { config } = await import("./config.js");
-      expect(config.repoPath).toBe("/custom/repo/path");
+      expect(config.repoPath).toBe(process.cwd().replace(/\/mcp$/, ""));
+    });
+
+    it("should fallback to BOOMTICK_REPO_PATH when process.cwd() is outside any repo", async () => {
+      process.env.BOOMTICK_REPO_PATH = "/custom/repo/path";
+      const { findRepoRoot } = await import("./config/repo.js");
+      const rootDir = process.platform === "win32" ? "C:\\" : "/";
+      expect(findRepoRoot(rootDir)).toBe("/custom/repo/path");
     });
 
     it("should resolve defaultBaseBranch, viteBasePath, and ghPath", async () => {

package/src/lib/git.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi, beforeEach } from "vitest";
-import { getChangedFiles, getMergeConflictFiles } from "./git.js";
+import { getChangedFiles, getMergeConflictFiles, resolveRepoPath, createWorktree } from "./git.js";
 import * as shell from "./shell.js";
 
 vi.mock("./shell.js", () => ({
@@ -107,4 +107,48 @@ describe("Git Helpers", () => {
       );
     });
   });
+
+  describe("resolveRepoPath", () => {
+    it("should return explicit path when path is provided", () => {
+      const resolved = resolveRepoPath({ path: "/tmp/custom-repo" });
+      expect(resolved).toBe("/tmp/custom-repo");
+    });
+
+    it("should return explicit repoPath when repoPath is provided", () => {
+      const resolved = resolveRepoPath({ repoPath: "/tmp/another-repo" });
+      expect(resolved).toBe("/tmp/another-repo");
+    });
+
+    it("should resolve repo path via ecosystem_repos when repo is given", () => {
+      const resolved = resolveRepoPath({ repo: "arii/tech-dancer" });
+      expect(resolved).toContain("tech-dancer");
+    });
+
+    it("should fall back to current working directory when empty", () => {
+      const resolved = resolveRepoPath({});
+      expect(typeof resolved).toBe("string");
+      expect(resolved.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("createWorktree", () => {
+    it("should pass baseRepoPath cwd to runCommand when provided", async () => {
+      vi.mocked(shell.runCommand).mockResolvedValue({
+        exitCode: 0,
+        stdout: "",
+        stderr: "",
+        durationMs: 5,
+        command: "git",
+      });
+
+      const worktree = await createWorktree("origin/feature", 123, "/home/ari/tech-dancer");
+
+      expect(worktree).toContain("boomtick-mcp-rescue-123");
+      expect(shell.runCommand).toHaveBeenCalledWith(
+        "git",
+        expect.arrayContaining(["worktree", "add"]),
+        { cwd: "/home/ari/tech-dancer" }
+      );
+    });
+  });
 });