@arii/boomtick-mcp 0.6.2 → 0.7.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.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;