metheus-governance-mcp-cli 0.2.36 → 0.2.37

package/cli.mjs

@@ -3491,6 +3491,83 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function normalizeSafeToolAliasName(rawName) {
+  const base = String(rawName || "")
+    .trim()
+    .replace(/[^a-zA-Z0-9_]/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  if (!base) return "";
+  if (/^[0-9]/.test(base)) return `tool_${base}`;
+  return base;
+}
+
+function buildToolAliasMaps(tools) {
+  const canonicalNames = new Set(
+    ensureArray(tools)
+      .map((tool) => String(tool?.name || "").trim())
+      .filter(Boolean),
+  );
+  const aliasToCanonical = new Map();
+  const canonicalToAlias = new Map();
+  const reserved = new Set(canonicalNames);
+
+  for (const canonicalName of canonicalNames) {
+    const aliasBase = normalizeSafeToolAliasName(canonicalName);
+    if (!aliasBase || aliasBase === canonicalName) continue;
+    let alias = aliasBase;
+    let counter = 2;
+    while (reserved.has(alias) || aliasToCanonical.has(alias)) {
+      alias = `${aliasBase}_${counter}`;
+      counter += 1;
+    }
+    aliasToCanonical.set(alias, canonicalName);
+    canonicalToAlias.set(canonicalName, alias);
+    reserved.add(alias);
+  }
+  return { aliasToCanonical, canonicalToAlias };
+}
+
+function applyToolAliasesToToolsListResponse(responseObj, canonicalToAlias) {
+  const result = safeObject(responseObj.result);
+  const tools = ensureArray(result.tools);
+  result.tools = tools.map((tool) => {
+    const safeTool = safeObject(tool);
+    const currentName = String(safeTool.name || "").trim();
+    const aliasName = canonicalToAlias.get(currentName);
+    if (!aliasName) return safeTool;
+    return { ...safeTool, name: aliasName };
+  });
+  responseObj.result = result;
+  return responseObj;
+}
+
+function rewriteAliasedToolCallToCanonical(requestObj, aliasToCanonical) {
+  if (!isJsonRpcMethod(requestObj, "tools/call")) return requestObj;
+  const params = safeObject(requestObj.params);
+  const currentName = String(params.name ?? params.tool_name ?? params.toolName ?? "").trim();
+  if (!currentName) return requestObj;
+  const canonicalName = String(aliasToCanonical.get(currentName) || "").trim();
+  if (!canonicalName) return requestObj;
+
+  const nextParams = { ...params, name: canonicalName };
+  if (Object.prototype.hasOwnProperty.call(nextParams, "tool_name")) {
+    nextParams.tool_name = canonicalName;
+  }
+  if (Object.prototype.hasOwnProperty.call(nextParams, "toolName")) {
+    nextParams.toolName = canonicalName;
+  }
+  return { ...requestObj, params: nextParams };
+}
+
+function shouldUseSafeToolAliasesForClient(initParamsRaw) {
+  const initParams = safeObject(initParamsRaw);
+  const clientInfo = safeObject(initParams.clientInfo);
+  const name = String(clientInfo.name || "").trim().toLowerCase();
+  if (!name) return false;
+  return name.includes("cursor") || name.includes("antigravity");
+}
+
 function injectWorkspaceDirIntoToolSchemas(tools) {
   const workspaceDirProp = {
     type: "string",
@@ -4044,6 +4121,9 @@ async function runProxy(flags) {
   let lastRefreshError = "";
   let sessionWorkspaceDir = "";
   let sessionWorkspaceTrusted = false;
+  let sessionUseSafeToolAliases = false;
+  let sessionToolAliasToCanonical = new Map();
+  let sessionToolCanonicalToAlias = new Map();
 
   // Proxy-initiated requests (e.g., roots/list) pending client responses.
   const pendingProxyRequests = new Map(); // id → callback(responseObj)
@@ -4122,7 +4202,7 @@ async function runProxy(flags) {
     const line = String(lineRaw || "").trim();
     if (!line) return;
 
-    const requestObj = tryJsonParse(line);
+    let requestObj = tryJsonParse(line);
     if (requestObj == null) {
       writeProxyJson(jsonRpcError(null, -32700, "parse error"));
       return;
@@ -4175,6 +4255,13 @@ async function runProxy(flags) {
       return;
     }
 
+    if (isJsonRpcMethod(requestObj, "initialize") && shouldUseSafeToolAliasesForClient(requestObj?.params)) {
+      sessionUseSafeToolAliases = true;
+    }
+    if (sessionUseSafeToolAliases) {
+      requestObj = rewriteAliasedToolCallToCanonical(requestObj, sessionToolAliasToCanonical);
+    }
+
     const { name: toolName, args: toolArgs } = extractToolCall(requestObj);
     let strongRequestWorkspaceCandidate = "";
     let weakRequestWorkspaceCandidate = "";
@@ -4430,6 +4517,13 @@ async function runProxy(flags) {
           }
           if (isJsonRpcMethod(requestObj, "tools/list")) {
             patched = appendLocalToolToToolsList(patched);
+            if (sessionUseSafeToolAliases) {
+              const tools = ensureArray(safeObject(patched.result).tools);
+              const aliasMaps = buildToolAliasMaps(tools);
+              sessionToolAliasToCanonical = aliasMaps.aliasToCanonical;
+              sessionToolCanonicalToAlias = aliasMaps.canonicalToAlias;
+              patched = applyToolAliasesToToolsListResponse(patched, sessionToolCanonicalToAlias);
+            }
           } else if (isJsonRpcMethod(requestObj, "initialize")) {
             patched = appendProjectHintToInitialize(patched, args);
             // Log initialize params for workspace debugging.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [