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

package/package.json

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

package/src/resultPathMapping.js

@@ -55,17 +55,75 @@ 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;
+    }
+
+    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 relNative = _posixToNative(rel);
+        return path.join(root, relNative);
+      }
+      return p;
+    }
+
+    // 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,18 +165,42 @@ 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 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;
+            }
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
     if (s.startsWith("/work/")) {
       const rest = s.slice("/work/".length);
       const parts = rest.split("/").filter(Boolean);
@@ -191,18 +273,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,24 +313,25 @@ 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;
   }