@arii/boomtick-mcp 0.6.1 → 0.7.0

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/dist/tools/repo.run_tests.js

@@ -61,5 +61,17 @@ export async function runTestsHandler(args) {
             break;
         }
     }
-    return { success, results };
+    const exitCode = results.length > 0 ? results[results.length - 1].exitCode : 0;
+    const failedTests = [];
+    for (const res of results) {
+        if (res.exitCode !== 0) {
+            failedTests.push(res.command);
+        }
+    }
+    return {
+        passed: success,
+        exitCode,
+        failedTests,
+        results,
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Boomtick MCP Guide: PR Rescue + Merge Conflict Agent",
   "repository": {
     "type": "git",
@@ -13,7 +13,8 @@
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "boomtick-mcp": "dist/index.js"
+    "boomtick-mcp": "dist/index.js",
+    "boomtick-mcp-http": "dist/http.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.0",

package/scripts/sync-contracts.ts

@@ -216,9 +216,18 @@ async function syncContracts() {
   if (!fs.existsSync(path.join(rootDir, 'pnpm-workspace.yaml'))) {
     rootDir = path.dirname(rootDir);
   }
-  const pythonScriptPath = path.join(rootDir, 'cli/dev_tools/schema_gen.py');
   console.log(`Regenerating cli-schema.json...`);
-  execFileSync('python3', [pythonScriptPath], { cwd: rootDir, stdio: 'inherit' });
+  const cliDir = path.join(rootDir, 'cli');
+  const existingPythonPath = process.env.PYTHONPATH || '';
+  const newPythonPath = existingPythonPath ? `${existingPythonPath}${path.delimiter}${cliDir}` : cliDir;
+  execFileSync('python3', ['-m', 'dev_tools.schema_gen'], {
+    cwd: rootDir,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      PYTHONPATH: newPythonPath,
+    },
+  });
 
   // Then perform the original Zod contract generation
   let jsonSchemaToZod;

package/src/config/dynamic.ts

@@ -0,0 +1,37 @@
+import { execSync } from "child_process";
+import { findRepoRoot } from "./repo.js";
+
+let cachedDynamicConfig: any = null;
+
+export function initializeConfig(targetCwd?: string) {
+  if (cachedDynamicConfig !== null) {
+    return cachedDynamicConfig;
+  }
+
+  try {
+    const cwd = findRepoRoot(targetCwd);
+    const cmd = `td config view`;
+    const output = execSync(cmd, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    cachedDynamicConfig = JSON.parse(output);
+    return cachedDynamicConfig;
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    const errorPrefix = `CRITICAL: Failed to load dynamic config from Python CLI. Ensure Python 3 is installed and cli is in your PYTHONPATH. Details: ${message}`;
+
+    if (process.env.NODE_ENV === "development" || process.env.CI === "true") {
+      throw new Error(errorPrefix);
+    } else {
+      console.warn(errorPrefix);
+    }
+    cachedDynamicConfig = {};
+  }
+  return cachedDynamicConfig;
+}
+
+export function getCachedDynamicConfig(): any {
+  return cachedDynamicConfig;
+}

package/src/config/github.ts

@@ -0,0 +1,16 @@
+import { execSync } from "child_process";
+
+export function getGithubToken(): string | undefined {
+  if (process.env.GITHUB_TOKEN) {
+    return process.env.GITHUB_TOKEN;
+  }
+  try {
+    const token = execSync("gh auth token", { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (token) {
+      return token;
+    }
+  } catch {
+    /* ignore to allow fallback */
+  }
+  return undefined;
+}

package/src/config/repo.ts

@@ -0,0 +1,36 @@
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+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")) ||
+      fs.existsSync(path.join(current, "workspace.json")) ||
+      fs.existsSync(path.join(current, ".git"))
+    ) {
+      return current;
+    }
+    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 (
+      fs.existsSync(path.join(current, "project_config.json")) ||
+      fs.existsSync(path.join(current, "workspace.json")) ||
+      fs.existsSync(path.join(current, ".git"))
+    ) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  return path.resolve(__dirname, "../../../../");
+}

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

@@ -1,7 +1,9 @@
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
-import { execSync } from "child_process";
+import { findRepoRoot } from "./config/repo.js";
+import { getGithubToken } from "./config/github.js";
+import { initializeConfig, getCachedDynamicConfig } from "./config/dynamic.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -14,93 +16,14 @@ if (fs.existsSync(envPath) && typeof process.loadEnvFile === "function") {
   }
 }
 
-function getGithubToken(): string | undefined {
-  if (process.env.GITHUB_TOKEN) {
-    return process.env.GITHUB_TOKEN;
-  }
-  try {
-    const token = execSync("gh auth token", { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-    if (token) {
-      return token;
-    }
-  } catch (e) { /* ignore to allow fallback */ }
-  return undefined;
-}
-
-let cachedDynamicConfig: any = null;
-
-/**
- * Explicitly initializes dynamic configuration from the Python CLI.
- * Should be called once during server startup.
- */
-export function initializeConfig() {
-  if (cachedDynamicConfig !== null) {
-    return cachedDynamicConfig;
-  }
-
-  try {
-    // Attempt to load core properties from the Python CLI in the active workspace
-    const cwd = process.env.BOOMTICK_REPO_PATH || process.cwd();
-    const cmd = `td config view`;
-    const output = execSync(cmd, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    cachedDynamicConfig = JSON.parse(output);
-    return cachedDynamicConfig;
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    const errorPrefix = `CRITICAL: Failed to load dynamic config from Python CLI. Ensure Python 3 is installed and cli is in your PYTHONPATH. Details: ${message}`;
-
-    if (process.env.NODE_ENV === "development" || process.env.CI === "true") {
-      throw new Error(errorPrefix);
-    } else {
-      console.warn(errorPrefix);
-    }
-    // Set an empty object to prevent repeated attempts if initialization fails in non-blocking mode
-    cachedDynamicConfig = {};
-  }
-  return cachedDynamicConfig;
-}
-
-function findRepoRoot() {
-  if (process.env.BOOMTICK_REPO_PATH) {
-    return process.env.BOOMTICK_REPO_PATH;
-  }
-
-  // Traverse up from process.cwd() to find project_config.json, workspace.json, or .git
-  let current = process.cwd();
-  while (current !== path.parse(current).root) {
-    if (
-      fs.existsSync(path.join(current, "project_config.json")) ||
-      fs.existsSync(path.join(current, "workspace.json")) ||
-      fs.existsSync(path.join(current, ".git"))
-    ) {
-      return current;
-    }
-    current = path.dirname(current);
-  }
-
-  // Fallback to __dirname search if discovery from cwd fails
-  current = __dirname;
-  while (current !== path.parse(current).root) {
-    if (
-      fs.existsSync(path.join(current, "project_config.json")) ||
-      fs.existsSync(path.join(current, "workspace.json")) ||
-      fs.existsSync(path.join(current, ".git"))
-    ) {
-      return current;
-    }
-    current = path.dirname(current);
-  }
-  // Fallback to the monolithic relative path if discovery fails
-  return path.resolve(__dirname, "../../../");
-}
+export { initializeConfig };
 
 export const config = {
-  get githubToken() { return getGithubToken(); },
+  get githubToken() {
+    return getGithubToken();
+  },
   get githubOwner() {
+    const cachedDynamicConfig = getCachedDynamicConfig();
     const repoString = cachedDynamicConfig?.github_repo;
     if (typeof repoString === "string" && repoString.includes("/")) {
       return repoString.split("/")[0];
@@ -113,6 +36,7 @@ export const config = {
     throw new Error("GITHUB_OWNER must be set via environment variable or project_config.json");
   },
   get githubRepo() {
+    const cachedDynamicConfig = getCachedDynamicConfig();
     const repoString = cachedDynamicConfig?.github_repo;
     if (typeof repoString === "string" && repoString.includes("/")) {
       return repoString.split("/")[1];
@@ -128,16 +52,19 @@ export const config = {
     return findRepoRoot();
   },
   get defaultBaseBranch() {
+    const cachedDynamicConfig = getCachedDynamicConfig();
     return process.env.DEFAULT_BASE_BRANCH || cachedDynamicConfig?.base_branch?.split("/").pop() || "main";
   },
   get viteBasePath() {
-    const path = process.env.VITE_BASE_PATH || cachedDynamicConfig?.vite_base_path;
-    if (!path) {
+    const cachedDynamicConfig = getCachedDynamicConfig();
+    const pathValue = process.env.VITE_BASE_PATH || cachedDynamicConfig?.vite_base_path;
+    if (!pathValue) {
       throw new Error("VITE_BASE_PATH must be set via environment variable or project_config.json");
     }
-    return path;
+    return pathValue;
   },
   get ghPath() {
+    const cachedDynamicConfig = getCachedDynamicConfig();
     return process.env.GH_PATH || cachedDynamicConfig?.gh_path || "gh";
-  }
+  },
 };

package/src/http.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { BoomtickMCPServer } from "./mcp/server.js";
+import { initializeConfig } from "./config.js";
+
+initializeConfig();
+
+process.env.MCP_TRANSPORT = "http";
+
+const server = new BoomtickMCPServer();
+server.run().catch((error) => {
+  console.error("Fatal error running HTTP server:", error);
+  process.exit(1);
+});