@context-engine-bridge/context-engine-mcp-bridge 0.0.7 → 0.0.9

package/README.md

@@ -15,7 +15,7 @@ other MCP clients) as long as the Context Engine stack is running.
 ## Prerequisites
 
 - Node.js **>= 18** (see `engines` in `package.json`).
-- A running Context Engine stack (e.g. via `docker-compose.dev-remote.yml`) with:
+- A running Context Engine stack (e.g. via `docker-compose.yml`) with:
   - MCP indexer HTTP endpoint (default: `http://localhost:8003/mcp`).
   - MCP memory HTTP endpoint (optional, default: `http://localhost:8002/mcp`).
 - For optional auth:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Context Engine MCP bridge (http/stdio proxy combining indexer + memory servers)",
   "bin": {
     "ctxce": "bin/ctxce.js",

package/src/mcpServer.js

@@ -10,7 +10,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { loadAnyAuthEntry, loadAuthEntry } from "./authConfig.js";
-import { maybeRemapToolResult } from "./resultPathMapping.js";
+import { maybeRemapToolArgs, maybeRemapToolResult } from "./resultPathMapping.js";
 
 function debugLog(message) {
   try {
@@ -503,6 +503,8 @@ async function createBridgeServer(options) {
       args = obj;
     }
 
+    args = maybeRemapToolArgs(name, args, workspace);
+
     if (name === "set_session_defaults") {
       const indexerResult = await indexerClient.callTool({ name, arguments: args });
       if (memoryClient) {

package/src/resultPathMapping.js

@@ -28,18 +28,170 @@ function _posixToNative(rel) {
   }
 }
 
-function computeWorkspaceRelativePath(containerPath, hostPath) {
+function _nativeToPosix(p) {
   try {
-    const cont = typeof containerPath === "string" ? containerPath.trim() : "";
-    if (cont.startsWith("/work/")) {
-      const rest = cont.slice("/work/".length);
-      const parts = rest.split("/").filter(Boolean);
-      if (parts.length >= 2) {
-        return parts.slice(1).join("/");
+    if (!p) {
+      return "";
+    }
+    return String(p).split(path.sep).join("/");
+  } catch {
+    return p;
+  }
+}
+
+function _workPathToRepoRelPosix(p) {
+  try {
+    const s = typeof p === "string" ? p.trim() : "";
+    if (!s || !s.startsWith("/work/")) {
+      return null;
+    }
+    const rest = s.slice("/work/".length);
+    const parts = rest.split("/").filter(Boolean);
+    if (parts.length >= 2) {
+      return parts.slice(1).join("/");
+    }
+    if (parts.length === 1) {
+      return parts[0];
+    }
+    return "";
+  } catch {
+    return null;
+  }
+}
+
+function normalizeToolArgPath(p, workspaceRoot) {
+  try {
+    const s = typeof p === "string" ? p.trim() : "";
+    if (!s) {
+      return p;
+    }
+
+    const root = typeof workspaceRoot === "string" ? workspaceRoot : "";
+    const sPosix = s.replace(/\\/g, "/");
+
+    const fromWork = _workPathToRepoRelPosix(sPosix);
+    if (typeof fromWork === "string" && fromWork) {
+      return fromWork;
+    }
+    if (fromWork === "") {
+      return p;
+    }
+
+    if (root) {
+      try {
+        const sNorm = s.replace(/\\/g, path.sep);
+        const rootNorm = root.replace(/\\/g, path.sep);
+        if (sNorm === rootNorm || sNorm.startsWith(rootNorm + path.sep)) {
+          const relNative = path.relative(rootNorm, sNorm);
+          const relPosix = _nativeToPosix(relNative);
+          if (relPosix && relPosix !== "." && relPosix !== ".." && !relPosix.startsWith("../")) {
+            return relPosix;
+          }
+        }
+      } catch {
+        // ignore
+      }
+      try {
+        const base = path.posix.basename(root.replace(/\\/g, "/"));
+        if (base && sPosix.startsWith(base + "/")) {
+          const rest = sPosix.slice((base + "/").length);
+          if (rest && rest !== "." && rest !== ".." && !rest.startsWith("../")) {
+            return rest;
+          }
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    if (sPosix.startsWith("./")) {
+      const rest = sPosix.slice(2);
+      if (rest && rest !== "." && rest !== ".." && !rest.startsWith("../")) {
+        return rest;
+      }
+    }
+    if (sPosix === ".") {
+      return "";
+    }
+    return p;
+  } catch {
+    return p;
+  }
+}
+
+function normalizeToolArgGlob(p, workspaceRoot) {
+  try {
+    const s = typeof p === "string" ? p : "";
+    if (!s) {
+      return p;
+    }
+    // TODO(ctxce): If this becomes annoying, consider making glob normalization
+    // more conservative (e.g. only strip a repo prefix when followed by "/",
+    // and avoid collapsing "<repo>/**" into "**" which can broaden scope).
+    if (s.startsWith("!")) {
+      const rest = s.slice(1);
+      const mapped = normalizeToolArgPath(rest, workspaceRoot);
+      if (typeof mapped === "string") {
+        return "!" + mapped;
+      }
+      return p;
+    }
+    return normalizeToolArgPath(s, workspaceRoot);
+  } catch {
+    return p;
+  }
+}
+
+function applyPathMappingToArgs(value, workspaceRoot, keyHint = "") {
+  try {
+    if (value === null || value === undefined) {
+      return value;
+    }
+
+    const key = typeof keyHint === "string" ? keyHint : "";
+    const lowered = key.toLowerCase();
+    const shouldMapString =
+      lowered === "path" ||
+      lowered === "under" ||
+      lowered === "root" ||
+      lowered === "subdir" ||
+      lowered === "path_glob" ||
+      lowered === "not_glob";
+
+    if (typeof value === "string") {
+      if (!shouldMapString) {
+        return value;
       }
-      if (parts.length === 1) {
-        return parts[0];
+      if (lowered === "path_glob" || lowered === "not_glob") {
+        return normalizeToolArgGlob(value, workspaceRoot);
+      }
+      return normalizeToolArgPath(value, workspaceRoot);
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((v) => applyPathMappingToArgs(v, workspaceRoot, keyHint));
+    }
+
+    if (typeof value === "object") {
+      const out = { ...value };
+      for (const [k, v] of Object.entries(out)) {
+        out[k] = applyPathMappingToArgs(v, workspaceRoot, k);
       }
+      return out;
+    }
+
+    return value;
+  } catch {
+    return value;
+  }
+}
+
+function computeWorkspaceRelativePath(containerPath, hostPath) {
+  try {
+    const cont = typeof containerPath === "string" ? containerPath.trim() : "";
+    const rel = _workPathToRepoRelPosix(cont);
+    if (typeof rel === "string" && rel) {
+      return rel;
     }
   } catch {
   }
@@ -55,17 +207,70 @@ function computeWorkspaceRelativePath(containerPath, hostPath) {
   }
 }
 
+function remapRelatedPathToClient(p, workspaceRoot) {
+  try {
+    const s = typeof p === "string" ? p : "";
+    const root = typeof workspaceRoot === "string" ? workspaceRoot : "";
+    if (!s || !root) {
+      return p;
+    }
+
+    const sNorm = s.replace(/\\/g, path.sep);
+    if (sNorm.startsWith(root + path.sep) || sNorm === root) {
+      return sNorm;
+    }
+
+    const rel = _workPathToRepoRelPosix(s);
+    if (typeof rel === "string" && rel) {
+      const relNative = _posixToNative(rel);
+      return path.join(root, relNative);
+    }
+
+    // If it's already a relative path, join it to the workspace root.
+    if (!s.startsWith("/") && !s.includes(":") && !s.includes("\\")) {
+      const relPosix = s.trim();
+      if (relPosix && relPosix !== "." && !relPosix.startsWith("../") && relPosix !== "..") {
+        const relNative = _posixToNative(relPosix);
+        const joined = path.join(root, relNative);
+        const relCheck = path.relative(root, joined);
+        if (relCheck && !relCheck.startsWith(`..${path.sep}`) && relCheck !== "..") {
+          return joined;
+        }
+      }
+    }
+
+    return p;
+  } catch {
+    return p;
+  }
+}
+
 function remapHitPaths(hit, workspaceRoot) {
   if (!hit || typeof hit !== "object") {
     return hit;
   }
-  const hostPath = typeof hit.host_path === "string" ? hit.host_path : "";
-  const containerPath = typeof hit.container_path === "string" ? hit.container_path : "";
+  const rawPath = typeof hit.path === "string" ? hit.path : "";
+  let hostPath = typeof hit.host_path === "string" ? hit.host_path : "";
+  let containerPath = typeof hit.container_path === "string" ? hit.container_path : "";
+  if (!hostPath && rawPath) {
+    hostPath = rawPath;
+  }
+  if (!containerPath && rawPath) {
+    containerPath = rawPath;
+  }
   const relPath = computeWorkspaceRelativePath(containerPath, hostPath);
   const out = { ...hit };
   if (relPath) {
     out.rel_path = relPath;
   }
+  // Remap related_paths nested under each hit (repo_search/hybrid_search emit this per result).
+  try {
+    if (Array.isArray(out.related_paths)) {
+      out.related_paths = out.related_paths.map((p) => remapRelatedPathToClient(p, workspaceRoot));
+    }
+  } catch {
+    // ignore
+  }
   if (workspaceRoot && relPath) {
     try {
       const relNative = _posixToNative(relPath);
@@ -107,29 +312,49 @@ function remapHitPaths(hit, workspaceRoot) {
     }
   }
   const overridePath = envTruthy(process.env.CTXCE_BRIDGE_OVERRIDE_PATH, true);
-  if (overridePath && relPath) {
-    out.path = relPath;
+  if (overridePath) {
+    if (typeof out.client_path === "string" && out.client_path) {
+      out.path = out.client_path;
+    } else if (relPath) {
+      out.path = relPath;
+    }
   }
   return out;
 }
 
-function remapStringPath(p) {
+function remapStringPath(p, workspaceRoot) {
   try {
     const s = typeof p === "string" ? p : "";
     if (!s) {
       return p;
     }
-    if (s.startsWith("/work/")) {
-      const rest = s.slice("/work/".length);
-      const parts = rest.split("/").filter(Boolean);
-      if (parts.length >= 2) {
-        const rel = parts.slice(1).join("/");
-        const override = envTruthy(process.env.CTXCE_BRIDGE_OVERRIDE_PATH, true);
-        if (override) {
-          return rel;
+    // If this is already a path within the current client workspace, rewrite to a
+    // workspace-relative string when override is enabled.
+    try {
+      const root = typeof workspaceRoot === "string" ? workspaceRoot : "";
+      if (root) {
+        const sNorm = s.replace(/\\/g, path.sep);
+        if (sNorm.startsWith(root + path.sep) || sNorm === root) {
+          const relNative = path.relative(root, sNorm);
+          const relPosix = String(relNative).split(path.sep).join("/");
+          if (relPosix && !relPosix.startsWith("../") && relPosix !== "..") {
+            const override = envTruthy(process.env.CTXCE_BRIDGE_OVERRIDE_PATH, true);
+            if (override) {
+              return relPosix;
+            }
+          }
         }
-        return p;
       }
+    } catch {
+      // ignore
+    }
+    const rel = _workPathToRepoRelPosix(s);
+    if (typeof rel === "string" && rel) {
+      const override = envTruthy(process.env.CTXCE_BRIDGE_OVERRIDE_PATH, true);
+      if (override) {
+        return rel;
+      }
+      return p;
     }
     return p;
   } catch {
@@ -191,18 +416,7 @@ function applyPathMappingToPayload(payload, workspaceRoot) {
     out.citations = mapHitsArray(out.citations);
   }
   if (Array.isArray(out.related_paths)) {
-    out.related_paths = out.related_paths.map((p) => remapStringPath(p));
-  }
-
-  // context_search: {results:[{source:"code"|"memory", ...}]}
-  if (Array.isArray(out.results)) {
-    out.results = out.results.map((r) => {
-      if (!r || typeof r !== "object") {
-        return r;
-      }
-      // Only code results have path-like fields
-      return remapHitPaths(r, workspaceRoot);
-    });
+    out.related_paths = out.related_paths.map((p) => remapRelatedPathToClient(p, workspaceRoot));
   }
 
   // Some tools nest under {result:{...}}
@@ -242,25 +456,44 @@ export function maybeRemapToolResult(name, result, workspaceRoot) {
     }
 
     const mapped = applyPathMappingToPayload(parsed.value, workspaceRoot);
+    let outResult = result;
     if (parsed.mode === "structured") {
-      return { ...result, structuredContent: mapped };
+      outResult = { ...result, structuredContent: mapped };
     }
 
     // Replace text payload for clients that only read `content[].text`
     try {
-      const content = Array.isArray(result.content) ? result.content.slice() : [];
+      const content = Array.isArray(outResult.content) ? outResult.content.slice() : [];
       const idx = content.findIndex(
         (c) => c && c.type === "text" && typeof c.text === "string",
       );
       if (idx >= 0) {
         content[idx] = { ...content[idx], text: JSON.stringify(mapped) };
-        return { ...result, content };
+        outResult = { ...outResult, content };
       }
     } catch {
       // ignore
     }
-    return result;
+    return outResult;
   } catch {
     return result;
   }
 }
+
+export function maybeRemapToolArgs(name, args, workspaceRoot) {
+  try {
+    if (!name || !workspaceRoot) {
+      return args;
+    }
+    const enabled = envTruthy(process.env.CTXCE_BRIDGE_MAP_ARGS, true);
+    if (!enabled) {
+      return args;
+    }
+    if (args === null || args === undefined || typeof args !== "object") {
+      return args;
+    }
+    return applyPathMappingToArgs(args, workspaceRoot, "");
+  } catch {
+    return args;
+  }
+}