@massu/core 0.6.2 → 0.6.3

package/dist/cli.js

@@ -989,12 +989,12 @@ function addSummary(db, sessionId, summary) {
     Math.floor(now.getTime() / 1e3)
   );
 }
-function addUserPrompt(db, sessionId, text18, promptNumber) {
+function addUserPrompt(db, sessionId, text19, promptNumber) {
   const now = /* @__PURE__ */ new Date();
   db.prepare(`
     INSERT INTO user_prompts (session_id, prompt_text, prompt_number, created_at, created_at_epoch)
     VALUES (?, ?, ?, ?, ?)
-  `).run(sessionId, text18, promptNumber, now.toISOString(), Math.floor(now.getTime() / 1e3));
+  `).run(sessionId, text19, promptNumber, now.toISOString(), Math.floor(now.getTime() / 1e3));
 }
 function searchObservations(db, query, opts) {
   const limit = opts?.limit ?? 20;
@@ -3980,7 +3980,7 @@ function parseFromImportLine(line, lineNum) {
 function parsePlainImportLine(line, lineNum) {
   const results = [];
   const rest = line.replace(/^import\s+/, "");
-  const parts = rest.split(",").map((p18) => p18.trim()).filter((p18) => p18.length > 0);
+  const parts = rest.split(",").map((p19) => p19.trim()).filter((p19) => p19.length > 0);
   for (const part of parts) {
     const asMatch = part.match(/^(\S+)\s+as\s+(\S+)$/);
     const moduleName = asMatch ? asMatch[1] : part;
@@ -4141,8 +4141,8 @@ function joinLogicalLines(source) {
   }
   return logical;
 }
-function extractQuotedString(text18) {
-  const m = text18.match(/(['"])(.*?)\1/);
+function extractQuotedString(text19) {
+  const m = text19.match(/(['"])(.*?)\1/);
   return m ? m[2] : null;
 }
 function extractResponseModel(argStr) {
@@ -4209,8 +4209,8 @@ function parsePythonRoutes(source) {
   const logicalLines = joinLogicalLines(source);
   const pendingDecorators = [];
   for (let i = 0; i < logicalLines.length; i++) {
-    const { text: text18, startLine } = logicalLines[i];
-    const trimmed = text18.trim();
+    const { text: text19, startLine } = logicalLines[i];
+    const trimmed = text19.trim();
     const decoratorMatch = trimmed.match(
       /^@\s*(\w+)\s*\.\s*(\w+)\s*\((.*)\)\s*$/s
     );
@@ -4445,11 +4445,11 @@ function parseRelationship(argsStr) {
     back_populates: bpMatch ? bpMatch[1] : null
   };
 }
-function findClosingParen(text18, openIndex, openChar, closeChar) {
+function findClosingParen(text19, openIndex, openChar, closeChar) {
   let depth = 1;
-  for (let i = openIndex + 1; i < text18.length; i++) {
-    if (text18[i] === openChar) depth++;
-    else if (text18[i] === closeChar) {
+  for (let i = openIndex + 1; i < text19.length; i++) {
+    if (text19[i] === openChar) depth++;
+    else if (text19[i] === closeChar) {
       depth--;
       if (depth === 0) return i;
     }
@@ -4725,16 +4725,16 @@ function extractTableAndColumn(argsStr) {
   }
   return { table, column };
 }
-function splitTopLevelCommas(text18) {
+function splitTopLevelCommas(text19) {
   const parts = [];
   let current = "";
   let depth = 0;
   let inString = null;
-  for (let i = 0; i < text18.length; i++) {
-    const ch = text18[i];
+  for (let i = 0; i < text19.length; i++) {
+    const ch = text19[i];
     if (inString) {
       current += ch;
-      if (ch === inString && text18[i - 1] !== "\\") {
+      if (ch === inString && text19[i - 1] !== "\\") {
         inString = null;
       }
       continue;
@@ -5579,7 +5579,7 @@ function handleDocsAudit(args2) {
       const fileName = basename3(file);
       if (mapping.routers.includes(fileName)) {
         const procedures = extractProcedureNames(file);
-        const undocumented = procedures.filter((p18) => !contentMentions(content, p18));
+        const undocumented = procedures.filter((p19) => !contentMentions(content, p19));
         if (undocumented.length > 0) {
           staleReasons.push(
             `Router ${fileName}: procedures not documented: ${undocumented.slice(0, 5).join(", ")}${undocumented.length > 5 ? ` (+${undocumented.length - 5} more)` : ""}`
@@ -5905,26 +5905,26 @@ function handleToolPatterns(args2, db) {
     case "tool":
       lines.push("| Tool | Calls | Successes | Failures | Success Rate | Avg Output Size | Avg Input Size |");
       lines.push("|------|-------|-----------|----------|--------------|-----------------|----------------|");
-      for (const p18 of patterns) {
-        const total = p18.call_count;
-        const successes = p18.successes;
-        const failures = p18.failures;
+      for (const p19 of patterns) {
+        const total = p19.call_count;
+        const successes = p19.successes;
+        const failures = p19.failures;
         const rate = total > 0 ? Math.round(successes / total * 100) : 0;
-        lines.push(`| ${p18.tool_name} | ${total} | ${successes} | ${failures} | ${rate}% | ${Math.round(p18.avg_output_size ?? 0)} | ${Math.round(p18.avg_input_size ?? 0)} |`);
+        lines.push(`| ${p19.tool_name} | ${total} | ${successes} | ${failures} | ${rate}% | ${Math.round(p19.avg_output_size ?? 0)} | ${Math.round(p19.avg_input_size ?? 0)} |`);
       }
       break;
     case "session":
       lines.push("| Session | Calls | Unique Tools | Successes | Failures | Avg Output Size |");
       lines.push("|---------|-------|--------------|-----------|----------|-----------------|");
-      for (const p18 of patterns) {
-        lines.push(`| ${p18.session_id.slice(0, 8)}... | ${p18.call_count} | ${p18.unique_tools} | ${p18.successes} | ${p18.failures} | ${Math.round(p18.avg_output_size ?? 0)} |`);
+      for (const p19 of patterns) {
+        lines.push(`| ${p19.session_id.slice(0, 8)}... | ${p19.call_count} | ${p19.unique_tools} | ${p19.successes} | ${p19.failures} | ${Math.round(p19.avg_output_size ?? 0)} |`);
       }
       break;
     case "day":
       lines.push("| Day | Calls | Unique Tools | Successes |");
       lines.push("|-----|-------|--------------|-----------|");
-      for (const p18 of patterns) {
-        lines.push(`| ${p18.day} | ${p18.call_count} | ${p18.unique_tools} | ${p18.successes} |`);
+      for (const p19 of patterns) {
+        lines.push(`| ${p19.day} | ${p19.call_count} | ${p19.unique_tools} | ${p19.successes} |`);
       }
       break;
   }
@@ -6572,15 +6572,15 @@ function handleDetail2(args2, db) {
   }
   if (detail.procedures.length > 0) {
     lines.push(`### Procedures (${detail.procedures.length})`);
-    for (const p18 of detail.procedures) {
-      lines.push(`- ${p18.router_name}.${p18.procedure_name}${p18.procedure_type ? " (" + p18.procedure_type + ")" : ""}`);
+    for (const p19 of detail.procedures) {
+      lines.push(`- ${p19.router_name}.${p19.procedure_name}${p19.procedure_type ? " (" + p19.procedure_type + ")" : ""}`);
     }
     lines.push("");
   }
   if (detail.pages.length > 0) {
     lines.push(`### Pages (${detail.pages.length})`);
-    for (const p18 of detail.pages) {
-      lines.push(`- ${p18.page_route}${p18.portal ? " (" + p18.portal + ")" : ""}`);
+    for (const p19 of detail.pages) {
+      lines.push(`- ${p19.page_route}${p19.portal ? " (" + p19.portal + ")" : ""}`);
     }
     lines.push("");
   }
@@ -6663,7 +6663,7 @@ function handleValidate(args2, db) {
         lines.push(`  Missing components: ${item.missing_components.join(", ")}`);
       }
       if (item.missing_procedures.length > 0) {
-        lines.push(`  Missing procedures: ${item.missing_procedures.map((p18) => `${p18.router}.${p18.procedure}`).join(", ")}`);
+        lines.push(`  Missing procedures: ${item.missing_procedures.map((p19) => `${p19.router}.${p19.procedure}`).join(", ")}`);
       }
       if (item.missing_pages.length > 0) {
         lines.push(`  Missing pages: ${item.missing_pages.join(", ")}`);
@@ -6710,14 +6710,14 @@ function handleRegister(args2, db) {
   }
   const procedures = args2.procedures;
   if (procedures) {
-    for (const p18 of procedures) {
-      linkProcedure(db, featureId, p18.router, p18.procedure, p18.type);
+    for (const p19 of procedures) {
+      linkProcedure(db, featureId, p19.router, p19.procedure, p19.type);
     }
   }
   const pages = args2.pages;
   if (pages) {
-    for (const p18 of pages) {
-      linkPage(db, featureId, p18.route, p18.portal);
+    for (const p19 of pages) {
+      linkPage(db, featureId, p19.route, p19.portal);
     }
   }
   logChange(db, featureId, "created", `Registered via ${p4("sentinel_register")}`);
@@ -9652,22 +9652,22 @@ function buildCrossReferences(db) {
   }
   const chunks = db.prepare("SELECT id, content, metadata FROM knowledge_chunks").all();
   for (const chunk of chunks) {
-    const text18 = chunk.content;
-    const crRefs = text18.match(/CR-\d+/g);
+    const text19 = chunk.content;
+    const crRefs = text19.match(/CR-\d+/g);
     if (crRefs) {
       for (const cr of [...new Set(crRefs)]) {
         insertEdge.run("chunk", String(chunk.id), "cr", cr, "references");
         edgeCount++;
       }
     }
-    const vrRefs = text18.match(/VR-[\w-]+/g);
+    const vrRefs = text19.match(/VR-[\w-]+/g);
     if (vrRefs) {
       for (const vr of [...new Set(vrRefs)]) {
         insertEdge.run("chunk", String(chunk.id), "vr", vr, "references");
         edgeCount++;
       }
     }
-    const incRefs = text18.match(/Incident #(\d+)/gi);
+    const incRefs = text19.match(/Incident #(\d+)/gi);
     if (incRefs) {
       for (const ref of incRefs) {
         const numMatch = ref.match(/\d+/);
@@ -9713,7 +9713,7 @@ function indexAllKnowledge(db) {
   }
   if (existsSync19(paths.docsDir)) {
     const excludePatterns = getConfig().conventions?.excludePatterns ?? ["/ARCHIVE/", "/SESSION-HISTORY/"];
-    const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f) => !f.includes("/plans/") && !excludePatterns.some((p18) => f.includes(p18)));
+    const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f) => !f.includes("/plans/") && !excludePatterns.some((p19) => f.includes(p19)));
     files.push(...docsFiles);
   }
   const now = /* @__PURE__ */ new Date();
@@ -9880,7 +9880,7 @@ function isKnowledgeStale(db) {
   }
   if (existsSync19(paths.docsDir)) {
     const excludePatterns = getConfig().conventions?.excludePatterns ?? ["/ARCHIVE/", "/SESSION-HISTORY/"];
-    const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f) => !f.includes("/plans/") && !excludePatterns.some((p18) => f.includes(p18)));
+    const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f) => !f.includes("/plans/") && !excludePatterns.some((p19) => f.includes(p19)));
     files.push(...docsFiles);
   }
   for (const filePath of files) {
@@ -11734,13 +11734,368 @@ var init_python_tools = __esm({
   }
 });
 
-// src/tools.ts
+// src/mcp-bridge-tools.ts
+import { spawn } from "child_process";
 import { readFileSync as readFileSync22, existsSync as existsSync22 } from "fs";
-import { resolve as resolve18, basename as basename7 } from "path";
+import { resolve as resolve18 } from "path";
+function p17(baseName) {
+  return `${getConfig().toolPrefix}_${baseName}`;
+}
+function buildSubprocessEnv() {
+  const env = {};
+  const projectName = getConfig().project?.name?.toUpperCase() || "";
+  const safePrefixes = projectName ? [`${projectName}_CONFIG_`, `${projectName}_LOG_`] : [];
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!value) continue;
+    if (ENV_DENY_PATTERNS.some((pat) => key.includes(pat))) continue;
+    if (ENV_ALLOW_LIST.has(key)) {
+      env[key] = value;
+    } else if (safePrefixes.length > 0 && safePrefixes.some((pfx) => key.startsWith(pfx))) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function loadMcpConfig() {
+  const root = getProjectRoot();
+  const mcpPath = resolve18(root, ".mcp.json");
+  if (!existsSync22(mcpPath)) return {};
+  try {
+    const raw = JSON.parse(readFileSync22(mcpPath, "utf-8"));
+    const servers = {};
+    const mcpServers = raw.mcpServers || {};
+    const pfx = getConfig().toolPrefix;
+    for (const [name, config] of Object.entries(mcpServers)) {
+      if (name === pfx) continue;
+      servers[name] = config;
+    }
+    return servers;
+  } catch (e) {
+    console.error("[mcp-bridge] Failed to parse .mcp.json:", e);
+    return {};
+  }
+}
+async function mcpRequest(conn, method, params = {}) {
+  if (!conn.process || !conn.process.stdin || !conn.process.stdout) {
+    throw new Error("MCP process not connected");
+  }
+  conn.requestId++;
+  const request = {
+    jsonrpc: "2.0",
+    id: conn.requestId,
+    method,
+    params
+  };
+  return new Promise((resolve22, reject) => {
+    const timeout = setTimeout(() => {
+      conn.process?.stdout?.removeListener("data", onData);
+      reject(new Error(`MCP request timed out: ${method}`));
+    }, 3e4);
+    let buffer2 = "";
+    const onData = (data) => {
+      buffer2 += data.toString("utf-8");
+      const lines = buffer2.split("\n");
+      buffer2 = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const response = JSON.parse(line);
+          if (response.id === conn.requestId) {
+            clearTimeout(timeout);
+            conn.process?.stdout?.removeListener("data", onData);
+            if (response.error) {
+              reject(new Error(`MCP error ${response.error.code}: ${response.error.message}`));
+            } else {
+              resolve22(response.result || {});
+            }
+            return;
+          }
+        } catch (e) {
+          clearTimeout(timeout);
+          conn.process?.stdout?.removeListener("data", onData);
+          reject(new Error(`Failed to parse MCP response: ${e}`));
+          return;
+        }
+      }
+    };
+    conn.process.stdout.on("data", onData);
+    conn.process.stdin.write(JSON.stringify(request) + "\n");
+  });
+}
+async function connectToServer(name, config) {
+  const existing = connections.get(name);
+  if (existing?.connected && existing.process && !existing.process.killed) {
+    return existing;
+  }
+  const root = getProjectRoot();
+  const cwd = config.cwd ? resolve18(root, config.cwd) : root;
+  const args2 = config.args || [];
+  const proc = spawn(config.command, args2, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: buildSubprocessEnv()
+  });
+  const conn = {
+    config,
+    process: proc,
+    connected: false,
+    tools: [],
+    requestId: 0
+  };
+  try {
+    await mcpRequest(conn, "initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "massu-mcp-bridge", version: "1.0.0" }
+    });
+    if (proc.stdin) {
+      proc.stdin.write(JSON.stringify({
+        jsonrpc: "2.0",
+        method: "notifications/initialized",
+        params: {}
+      }) + "\n");
+    }
+    conn.connected = true;
+    const toolsResult = await mcpRequest(conn, "tools/list", {});
+    conn.tools = toolsResult.tools || [];
+    connections.set(name, conn);
+    return conn;
+  } catch (e) {
+    if (!proc.killed) proc.kill("SIGTERM");
+    throw e;
+  }
+}
+function disconnectServer(name) {
+  const conn = connections.get(name);
+  if (conn) {
+    conn.connected = false;
+    if (conn.process && !conn.process.killed) {
+      conn.process.kill("SIGTERM");
+      const proc = conn.process;
+      setTimeout(() => {
+        if (!proc.killed) {
+          try {
+            proc.kill("SIGKILL");
+          } catch {
+          }
+        }
+      }, 3e3);
+    }
+    connections.delete(name);
+  }
+}
+function text17(s) {
+  return { content: [{ type: "text", text: s }] };
+}
+function getMcpBridgeToolDefinitions() {
+  return [
+    {
+      name: p17("mcp_servers"),
+      description: "List all configured MCP servers from .mcp.json and their connection status.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    },
+    {
+      name: p17("mcp_tools"),
+      description: "List tools available from a specific MCP server. Connects to the server if not already connected.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          server: { type: "string", description: "MCP server name from .mcp.json" }
+        },
+        required: ["server"]
+      }
+    },
+    {
+      name: p17("mcp_call"),
+      description: "Call a tool on a connected MCP server. Connects automatically if needed.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          server: { type: "string", description: "MCP server name from .mcp.json" },
+          tool: { type: "string", description: "Tool name to call on the remote server" },
+          arguments: {
+            type: "object",
+            description: "Arguments to pass to the remote tool",
+            additionalProperties: true
+          }
+        },
+        required: ["server", "tool"]
+      }
+    },
+    {
+      name: p17("mcp_status"),
+      description: "Health check all MCP server connections. Shows which are connected, disconnected, or errored.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    }
+  ];
+}
+function isMcpBridgeTool(name) {
+  const pfx = getConfig().toolPrefix;
+  return name.startsWith(`${pfx}_mcp_`);
+}
+async function handleMcpBridgeToolCall(name, args2) {
+  const pfx = getConfig().toolPrefix;
+  const baseName = name.startsWith(`${pfx}_`) ? name.slice(pfx.length + 1) : name;
+  switch (baseName) {
+    case "mcp_servers":
+      return handleMcpServers();
+    case "mcp_tools":
+      return await handleMcpTools(args2.server);
+    case "mcp_call":
+      return await handleMcpCall(
+        args2.server,
+        args2.tool,
+        args2.arguments || {}
+      );
+    case "mcp_status":
+      return handleMcpStatus();
+    default:
+      return text17(`Unknown MCP bridge tool: ${name}`);
+  }
+}
+function handleMcpServers() {
+  const configs = loadMcpConfig();
+  const servers = Object.entries(configs).map(([name, config]) => {
+    const conn = connections.get(name);
+    return {
+      name,
+      command: config.command,
+      args: config.args || [],
+      cwd: config.cwd || ".",
+      status: conn?.connected ? "connected" : "disconnected",
+      toolCount: conn?.tools.length || 0
+    };
+  });
+  if (servers.length === 0) {
+    return text17("No MCP servers configured in .mcp.json (excluding self).");
+  }
+  const lines = ["# MCP Servers\n"];
+  for (const srv of servers) {
+    const status = srv.status === "connected" ? "CONNECTED" : "DISCONNECTED";
+    lines.push(`- **${srv.name}** [${status}] \u2014 \`${srv.command} ${srv.args.join(" ")}\` (${srv.toolCount} tools)`);
+  }
+  return text17(lines.join("\n"));
+}
+async function handleMcpTools(server) {
+  const configs = loadMcpConfig();
+  const config = configs[server];
+  if (!config) {
+    return text17(`MCP server "${server}" not found in .mcp.json. Available: ${Object.keys(configs).join(", ") || "none"}`);
+  }
+  try {
+    const conn = await connectToServer(server, config);
+    if (conn.tools.length === 0) {
+      return text17(`MCP server "${server}" is connected but has no tools.`);
+    }
+    const lines = [`# Tools from ${server} (${conn.tools.length})
+`];
+    for (const tool of conn.tools) {
+      lines.push(`- **${tool.name}**: ${tool.description}`);
+    }
+    return text17(lines.join("\n"));
+  } catch (e) {
+    return text17(`Failed to connect to MCP server "${server}": ${e}`);
+  }
+}
+async function handleMcpCall(server, tool, args2) {
+  const configs = loadMcpConfig();
+  const config = configs[server];
+  if (!config) {
+    return text17(`MCP server "${server}" not found in .mcp.json.`);
+  }
+  try {
+    const conn = await connectToServer(server, config);
+    const result = await mcpRequest(conn, "tools/call", { name: tool, arguments: args2 });
+    const content = result.content;
+    if (Array.isArray(content)) {
+      const texts = content.filter((c) => c.type === "text").map((c) => c.text);
+      if (result.isError) {
+        return text17(`MCP tool error: ${texts.join("\n")}`);
+      }
+      return text17(texts.join("\n"));
+    }
+    return text17(JSON.stringify(result, null, 2));
+  } catch (e) {
+    const conn = connections.get(server);
+    if (conn) conn.connected = false;
+    return text17(`MCP call failed (${server}/${tool}): ${e}`);
+  }
+}
+function handleMcpStatus() {
+  const configs = loadMcpConfig();
+  const lines = ["# MCP Connection Status\n"];
+  for (const [name] of Object.entries(configs)) {
+    const conn = connections.get(name);
+    if (!conn) {
+      lines.push(`- **${name}**: NOT CONNECTED`);
+    } else if (conn.connected && conn.process && !conn.process.killed) {
+      lines.push(`- **${name}**: HEALTHY (pid=${conn.process.pid}, ${conn.tools.length} tools)`);
+    } else {
+      lines.push(`- **${name}**: DISCONNECTED`);
+      disconnectServer(name);
+    }
+  }
+  if (Object.keys(configs).length === 0) {
+    lines.push("No MCP servers configured.");
+  }
+  return text17(lines.join("\n"));
+}
+var connections, ENV_ALLOW_LIST, ENV_DENY_PATTERNS;
+var init_mcp_bridge_tools = __esm({
+  "src/mcp-bridge-tools.ts"() {
+    "use strict";
+    init_config();
+    connections = /* @__PURE__ */ new Map();
+    process.on("exit", () => {
+      for (const [, conn] of connections) {
+        if (conn.process && !conn.process.killed) {
+          try {
+            conn.process.kill("SIGTERM");
+          } catch {
+          }
+        }
+      }
+    });
+    process.on("SIGTERM", () => {
+      for (const [name] of connections) disconnectServer(name);
+      process.exit(0);
+    });
+    ENV_ALLOW_LIST = /* @__PURE__ */ new Set([
+      "PATH",
+      "HOME",
+      "LANG",
+      "LC_ALL",
+      "TERM",
+      "PYTHONPATH",
+      "NODE_PATH"
+    ]);
+    ENV_DENY_PATTERNS = [
+      "PRIVATE_KEY",
+      "SECRET_KEY",
+      "API_SECRET",
+      "AUTH_DISABLED",
+      "COLD_STORAGE",
+      "PASSWORD",
+      "TOKEN"
+    ];
+  }
+});
+
+// src/tools.ts
+import { readFileSync as readFileSync23, existsSync as existsSync23 } from "fs";
+import { resolve as resolve19, basename as basename7 } from "path";
 function prefix() {
   return getConfig().toolPrefix;
 }
-function p17(name) {
+function p18(name) {
   return `${prefix()}_${name}`;
 }
 function stripPrefix3(name) {
@@ -11771,7 +12126,7 @@ function ensureIndexes(dataDb2, codegraphDb2, force = false) {
   if (config.python?.root) {
     const pythonRoot = config.python.root;
     const excludeDirs = config.python.exclude_dirs || ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"];
-    if (force || isPythonDataStale(dataDb2, resolve18(getProjectRoot(), pythonRoot))) {
+    if (force || isPythonDataStale(dataDb2, resolve19(getProjectRoot(), pythonRoot))) {
       const pyImports = buildPythonImportIndex(dataDb2, pythonRoot, excludeDirs);
       results.push(`Python imports: ${pyImports}`);
       const pyRoutes = buildPythonRouteIndex(dataDb2, pythonRoot, excludeDirs);
@@ -11820,11 +12175,13 @@ function getToolDefinitions() {
     ...getKnowledgeToolDefinitions(),
     // Python code intelligence tools
     ...getPythonToolDefinitions(),
+    // MCP bridge tools (cross-project tool mesh)
+    ...getMcpBridgeToolDefinitions(),
     // License tools (always available)
     ...getLicenseToolDefinitions(),
     // Core tools
     {
-      name: p17("sync"),
+      name: p18("sync"),
       description: "Force rebuild all indexes (import edges, tRPC mappings, page deps, middleware tree). Run this after significant code changes.",
       inputSchema: {
         type: "object",
@@ -11833,7 +12190,7 @@ function getToolDefinitions() {
       }
     },
     {
-      name: p17("context"),
+      name: p18("context"),
       description: "Get context for a file: applicable rules, pattern warnings, schema mismatch alerts, and whether the file is in the middleware import tree.",
       inputSchema: {
         type: "object",
@@ -11845,7 +12202,7 @@ function getToolDefinitions() {
     },
     ...config.framework.router === "trpc" ? [
       {
-        name: p17("trpc_map"),
+        name: p18("trpc_map"),
         description: "Map tRPC procedures to their UI call sites. Find which components call a router, which procedures have no UI callers, or list all procedures for a router.",
         inputSchema: {
           type: "object",
@@ -11858,7 +12215,7 @@ function getToolDefinitions() {
         }
       },
       {
-        name: p17("coupling_check"),
+        name: p18("coupling_check"),
         description: "Automated coupling check. Finds all procedures with zero UI callers and components not rendered in any page.",
         inputSchema: {
           type: "object",
@@ -11874,7 +12231,7 @@ function getToolDefinitions() {
       }
     ] : [],
     {
-      name: p17("impact"),
+      name: p18("impact"),
       description: "Full impact analysis for a file: which pages are affected, which database tables are in the chain, middleware tree membership, domain crossings.",
       inputSchema: {
         type: "object",
@@ -11885,7 +12242,7 @@ function getToolDefinitions() {
       }
     },
     ...config.domains.length > 0 ? [{
-      name: p17("domains"),
+      name: p18("domains"),
       description: "Domain boundary information. Classify a file into its domain, show cross-domain imports, or list all files in a domain.",
       inputSchema: {
         type: "object",
@@ -11898,7 +12255,7 @@ function getToolDefinitions() {
       }
     }] : [],
     ...config.framework.orm === "prisma" ? [{
-      name: p17("schema"),
+      name: p18("schema"),
       description: "Prisma schema cross-reference. Show columns for a table, detect mismatches between code and schema, or verify column references in a file.",
       inputSchema: {
         type: "object",
@@ -11916,7 +12273,7 @@ async function handleToolCall(name, args2, dataDb2, codegraphDb2) {
   const userTier = await getCurrentTier();
   const requiredTier = getToolTier(name);
   if (!isToolAllowed(name, userTier)) {
-    return text17(`This tool requires ${requiredTier} tier. Current tier: ${userTier}. Upgrade at https://massu.ai/pricing`);
+    return text18(`This tool requires ${requiredTier} tier. Current tier: ${userTier}. Upgrade at https://massu.ai/pricing`);
   }
   const syncMessage = ensureIndexes(dataDb2, codegraphDb2);
   const pfx = prefix();
@@ -12034,6 +12391,9 @@ async function handleToolCall(name, args2, dataDb2, codegraphDb2) {
     if (isPythonTool(name)) {
       return handlePythonToolCall(name, args2, dataDb2);
     }
+    if (isMcpBridgeTool(name)) {
+      return await handleMcpBridgeToolCall(name, args2);
+    }
     if (isLicenseTool(name)) {
       const memDb = getMemoryDb();
       try {
@@ -12059,26 +12419,26 @@ async function handleToolCall(name, args2, dataDb2, codegraphDb2) {
       case "schema":
         return handleSchema(args2);
       default:
-        return text17(`Unknown tool: ${name}`);
+        return text18(`Unknown tool: ${name}`);
     }
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     const safeMsg = msg.split("\n")[0].replace(/\/(Users|home|var|tmp)\/[^\s:]+/g, "<path>");
-    return text17(`Error in ${name}: ${safeMsg}`);
+    return text18(`Error in ${name}: ${safeMsg}`);
   }
 }
-function text17(content) {
+function text18(content) {
   return { content: [{ type: "text", text: content }] };
 }
 function handleSync(dataDb2, codegraphDb2) {
   const result = ensureIndexes(dataDb2, codegraphDb2, true);
   try {
     const scanResult = runFeatureScan(dataDb2);
-    return text17(`${result}
+    return text18(`${result}
 
 Feature scan: ${scanResult.registered} features registered (${scanResult.fromProcedures} from procedures, ${scanResult.fromPages} from pages, ${scanResult.fromComponents} from components)`);
   } catch (error) {
-    return text17(`${result}
+    return text18(`${result}
 
 Feature scan failed: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -12170,9 +12530,9 @@ function handleContext(file, dataDb2, codegraphDb2) {
         try {
           const resolvedPaths = getResolvedPaths();
           const root = getProjectRoot();
-          const absFilePath = ensureWithinRoot(resolve18(resolvedPaths.srcDir, "..", file), root);
-          if (existsSync22(absFilePath)) {
-            const fileContent = readFileSync22(absFilePath, "utf-8").slice(0, 3e3);
+          const absFilePath = ensureWithinRoot(resolve19(resolvedPaths.srcDir, "..", file), root);
+          if (existsSync23(absFilePath)) {
+            const fileContent = readFileSync23(absFilePath, "utf-8").slice(0, 3e3);
             const keywords = [];
             if (fileContent.includes("ctx.db")) keywords.push("database", "schema");
             if (fileContent.includes("BigInt") || fileContent.includes("Decimal")) keywords.push("BigInt", "serialization");
@@ -12294,7 +12654,7 @@ function handleContext(file, dataDb2, codegraphDb2) {
   } finally {
     memDb?.close();
   }
-  return text17(lines.join("\n") || "No context available for this file.");
+  return text18(lines.join("\n") || "No context available for this file.");
 }
 function handleTrpcMap(args2, dataDb2) {
   const lines = [];
@@ -12369,7 +12729,7 @@ function handleTrpcMap(args2, dataDb2) {
     lines.push('Use { router: "name" } to see details for a specific router.');
     lines.push("Use { uncoupled: true } to see all procedures without UI callers.");
   }
-  return text17(lines.join("\n"));
+  return text18(lines.join("\n"));
 }
 function handleCouplingCheck(args2, dataDb2, codegraphDb2) {
   const lines = [];
@@ -12427,7 +12787,7 @@ function handleCouplingCheck(args2, dataDb2, codegraphDb2) {
   }
   const totalIssues = uncoupledProcs.length + orphanComponents.length;
   lines.push(`### RESULT: ${totalIssues === 0 ? "PASS" : `FAIL (${totalIssues} issues)`}`);
-  return text17(lines.join("\n"));
+  return text18(lines.join("\n"));
 }
 function handleImpact2(file, dataDb2, codegraphDb2) {
   const lines = [];
@@ -12435,9 +12795,9 @@ function handleImpact2(file, dataDb2, codegraphDb2) {
   lines.push("");
   const affectedPages = findAffectedPages(dataDb2, file);
   if (affectedPages.length > 0) {
-    const portals = [...new Set(affectedPages.map((p18) => p18.portal))];
-    const allTables = [...new Set(affectedPages.flatMap((p18) => p18.tables))];
-    const allRouters = [...new Set(affectedPages.flatMap((p18) => p18.routers))];
+    const portals = [...new Set(affectedPages.map((p19) => p19.portal))];
+    const allTables = [...new Set(affectedPages.flatMap((p19) => p19.tables))];
+    const allRouters = [...new Set(affectedPages.flatMap((p19) => p19.routers))];
     lines.push(`### Pages Affected: ${affectedPages.length}`);
     for (const page of affectedPages) {
       lines.push(`- ${page.route} (${page.portal})`);
@@ -12489,7 +12849,7 @@ function handleImpact2(file, dataDb2, codegraphDb2) {
       lines.push(`- -> ${crossing}`);
     }
   }
-  return text17(lines.join("\n"));
+  return text18(lines.join("\n"));
 }
 function handleDomains(args2, dataDb2, codegraphDb2) {
   const lines = [];
@@ -12534,7 +12894,7 @@ function handleDomains(args2, dataDb2, codegraphDb2) {
     for (const r of files.routers) lines.push(`- ${r}`);
     lines.push("");
     lines.push(`### Pages (${files.pages.length})`);
-    for (const p18 of files.pages) lines.push(`- ${p18}`);
+    for (const p19 of files.pages) lines.push(`- ${p19}`);
     lines.push("");
     lines.push(`### Components (${files.components.length})`);
     for (const c of files.components.slice(0, 30)) lines.push(`- ${c}`);
@@ -12545,7 +12905,7 @@ function handleDomains(args2, dataDb2, codegraphDb2) {
       lines.push(`- **${domain.name}**: ${domain.routers.length} router patterns, imports from: ${domain.allowedImportsFrom.join(", ") || "any"}`);
     }
   }
-  return text17(lines.join("\n"));
+  return text18(lines.join("\n"));
 }
 function handleSchema(args2) {
   const lines = [];
@@ -12570,7 +12930,7 @@ function handleSchema(args2) {
     const tableName = args2.table;
     const model = models.find((m) => m.tableName === tableName || m.name === tableName);
     if (!model) {
-      return text17(`Model/table "${tableName}" not found in Prisma schema.`);
+      return text18(`Model/table "${tableName}" not found in Prisma schema.`);
     }
     lines.push(`## ${model.name} (table: ${model.tableName})`);
     lines.push("");
@@ -12596,11 +12956,11 @@ function handleSchema(args2) {
     lines.push("Checking all column references against Prisma schema...");
     lines.push("");
     const projectRoot = getProjectRoot();
-    const absPath = ensureWithinRoot(resolve18(projectRoot, file), projectRoot);
-    if (!existsSync22(absPath)) {
-      return text17(`File not found: ${file}`);
+    const absPath = ensureWithinRoot(resolve19(projectRoot, file), projectRoot);
+    if (!existsSync23(absPath)) {
+      return text18(`File not found: ${file}`);
     }
-    const source = readFileSync22(absPath, "utf-8");
+    const source = readFileSync23(absPath, "utf-8");
     const config = getConfig();
     const dbPattern = config.dbAccessPattern ?? "ctx.db.{table}";
     const regexStr = dbPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\{table\\}", "(\\w+)");
@@ -12633,7 +12993,7 @@ function handleSchema(args2) {
       }
     }
   }
-  return text17(lines.join("\n"));
+  return text18(lines.join("\n"));
 }
 var init_tools = __esm({
   "src/tools.ts"() {
@@ -12673,13 +13033,14 @@ var init_tools = __esm({
     init_python_tools();
     init_config();
     init_license();
+    init_mcp_bridge_tools();
   }
 });
 
 // src/server.ts
 var server_exports = {};
-import { readFileSync as readFileSync23 } from "fs";
-import { resolve as resolve19, dirname as dirname11 } from "path";
+import { readFileSync as readFileSync24 } from "fs";
+import { resolve as resolve20, dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function getDb() {
   if (!codegraphDb) codegraphDb = getCodeGraphDb();
@@ -12774,7 +13135,7 @@ var init_server = __esm({
     __dirname4 = dirname11(fileURLToPath4(import.meta.url));
     PKG_VERSION = (() => {
       try {
-        const pkg = JSON.parse(readFileSync23(resolve19(__dirname4, "..", "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync24(resolve20(__dirname4, "..", "package.json"), "utf-8"));
         return pkg.version ?? "0.0.0";
       } catch {
         return "0.0.0";
@@ -12838,8 +13199,8 @@ var init_server = __esm({
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync24 } from "fs";
-import { resolve as resolve20, dirname as dirname12 } from "path";
+import { readFileSync as readFileSync25 } from "fs";
+import { resolve as resolve21, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename4 = fileURLToPath5(import.meta.url);
 var __dirname5 = dirname12(__filename4);
@@ -12913,7 +13274,7 @@ Documentation: https://massu.ai/docs
 }
 function printVersion() {
   try {
-    const pkg = JSON.parse(readFileSync24(resolve20(__dirname5, "../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync25(resolve21(__dirname5, "../package.json"), "utf-8"));
     console.log(`massu v${pkg.version}`);
   } catch {
     console.log("massu v0.1.0");