@context-engine-bridge/context-engine-mcp-bridge 0.0.53 → 0.0.55

package/package.json

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

package/src/mcpServer.js

@@ -154,15 +154,18 @@ function _callLspHandler(port, secret, operation, params) {
       },
       timeout: 3000,
     }, (res) => {
-      let data = "";
+      const chunks = [];
+      let totalBytes = 0;
       const MAX_RESP = 5 * 1024 * 1024;
       res.on("error", () => settle(null));
       res.on("data", chunk => {
         if (settled) return;
-        data += chunk;
-        if (data.length > MAX_RESP) { req.destroy(); settle(null); }
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += buf.length;
+        if (totalBytes > MAX_RESP) { req.destroy(); settle(null); return; }
+        chunks.push(buf);
       });
-      res.on("end", () => { if (!settled) { try { settle(JSON.parse(data)); } catch { settle(null); } } });
+      res.on("end", () => { if (!settled) { try { settle(JSON.parse(Buffer.concat(chunks).toString("utf8"))); } catch { settle(null); } } });
     });
     req.on("error", () => settle(null));
     req.on("timeout", () => { req.destroy(); settle(null); });
@@ -1263,17 +1266,20 @@ async function createBridgeServer(options) {
             headers: Object.assign({ "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) }, lspSecret ? { "x-lsp-handler-token": lspSecret } : {}),
             timeout: LSP_DIRECT_TIMEOUT_MS,
           }, (res) => {
-            let data = "";
+            const chunks = [];
+            let totalBytes = 0;
             let exceeded = false;
             const MAX_RESP = 5 * 1024 * 1024;
             res.on("error", () => { if (!exceeded) resolve({ ok: false, error: "LSP response stream error" }); });
             res.on("data", chunk => {
               if (exceeded) return;
-              data += chunk;
-              if (data.length > MAX_RESP) { exceeded = true; req.destroy(); resolve({ ok: false, error: "Response too large" }); }
+              const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+              totalBytes += buf.length;
+              if (totalBytes > MAX_RESP) { exceeded = true; req.destroy(); resolve({ ok: false, error: "Response too large" }); return; }
+              chunks.push(buf);
             });
             res.on("end", () => {
-              if (!exceeded) { try { resolve(JSON.parse(data)); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); } }
+              if (!exceeded) { try { resolve(JSON.parse(Buffer.concat(chunks).toString("utf8"))); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); } }
             });
           });
           req.on("error", reject);
@@ -1293,6 +1299,18 @@ async function createBridgeServer(options) {
 
     await initializeRemoteClients(false);
 
+    const MAX_FANOUT_COLLECTIONS = 5;
+    const primaryCollection = args && typeof args.collection === "string" ? args.collection : "";
+    const primaryLower = primaryCollection.toLowerCase();
+    const additionalCollections = _FANOUT_TOOLS.has(name)
+      ? _loadSessionCollections(workspace).filter(c => c.toLowerCase() !== primaryLower).slice(0, MAX_FANOUT_COLLECTIONS)
+      : [];
+    const shouldFanOut = additionalCollections.length > 0 && indexerClient;
+
+    if (shouldFanOut) {
+      debugLog(`[ctxce] Fan-out: ${name} across ${additionalCollections.length} additional collection(s)`);
+    }
+
     const timeoutMs = getBridgeToolTimeoutMs();
     const maxAttempts = getBridgeRetryAttempts();
     const retryDelayMs = getBridgeRetryDelayMs();
@@ -1319,6 +1337,53 @@ async function createBridgeServer(options) {
           undefined,
           { timeout: timeoutMs },
         );
+
+        if (shouldFanOut) {
+          const fanOutTimeoutMs = Math.min(timeoutMs, 10000);
+          const fanOutPromises = additionalCollections.map(col => {
+            const colArgs = { ...args, collection: col };
+            return targetClient.callTool(
+              { name, arguments: colArgs },
+              undefined,
+              { timeout: fanOutTimeoutMs },
+            ).catch(err => {
+              debugLog(`[ctxce] Fan-out to ${col} failed: ${String(err)}`);
+              return null;
+            });
+          });
+
+          let fanOutTimer;
+          const fanOutDeadline = new Promise(resolve => { fanOutTimer = setTimeout(() => resolve(null), fanOutTimeoutMs); });
+          const fanOutResults = await Promise.race([
+            Promise.all(fanOutPromises),
+            fanOutDeadline.then(() => fanOutPromises.map(() => null)),
+          ]);
+          clearTimeout(fanOutTimer);
+          const additionalTexts = [];
+          for (const fr of fanOutResults) {
+            if (!fr) continue;
+            const tb = Array.isArray(fr.content) && fr.content.find(c => c.type === "text");
+            if (tb && tb.text) additionalTexts.push(tb.text);
+          }
+
+          if (additionalTexts.length > 0) {
+            const primaryTb = Array.isArray(result.content) && result.content.find(c => c.type === "text");
+            if (primaryTb && primaryTb.text) {
+              if (args && args.limit && !_isBatchTool(name)) {
+                try {
+                  const pObj = JSON.parse(primaryTb.text);
+                  if (pObj && pObj.ok) { pObj._original_limit = Number(args.limit); primaryTb.text = JSON.stringify(pObj); }
+                } catch (_) {}
+              }
+              const mergeFn = _isBatchTool(name) ? _mergeBatchResults : _mergeResults;
+              primaryTb.text = mergeFn(primaryTb.text, additionalTexts);
+              if (result.structuredContent) {
+                try { result.structuredContent = JSON.parse(primaryTb.text); } catch (_) {}
+              }
+            }
+          }
+        }
+
         const lspConn = includeLsp && _readLspConnection(workspace);
         if (includeLsp) {
           debugLog("[ctxce] LSP gate: tool=" + name + " lsp=" + (lspConn ? "port:" + lspConn.port : "null"));
@@ -1740,6 +1805,149 @@ export async function runHttpMcpServer(options) {
   process.on("SIGINT", () => shutdown("SIGINT"));
 }
 
+const _FANOUT_TOOLS = new Set([
+  "search", "repo_search", "code_search", "context_search",
+  "symbol_graph", "pattern_search",
+  "search_tests_for", "search_config_for", "search_callers_for",
+  "search_importers_for", "search_commits_for",
+  "batch_search", "batch_graph_query", "batch_symbol_graph",
+]);
+
+let _sessionCollectionsCache = null;
+let _sessionCollectionsMtime = 0;
+let _sessionCollectionsCacheKey = "";
+
+function _loadSessionCollections(workspacePath) {
+  if (!workspacePath) return [];
+  try {
+    const wsDir = _computeWorkspaceDir(workspacePath);
+    const filePath = path.join(wsDir, "session_collections.json");
+    let mtime = 0;
+    try {
+      mtime = fs.statSync(filePath).mtimeMs;
+    } catch (_) {
+      _sessionCollectionsCache = null;
+      _sessionCollectionsMtime = 0;
+      _sessionCollectionsCacheKey = "";
+      return [];
+    }
+    if (_sessionCollectionsCache && mtime === _sessionCollectionsMtime && _sessionCollectionsCacheKey === workspacePath) {
+      return _sessionCollectionsCache;
+    }
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      _sessionCollectionsCache = parsed.filter(c => c && typeof c === "string" && c.length <= 128 && /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(c));
+      _sessionCollectionsMtime = mtime;
+      _sessionCollectionsCacheKey = workspacePath;
+      return _sessionCollectionsCache;
+    }
+    return [];
+  } catch (_) {
+    return [];
+  }
+}
+
+function _isBatchTool(name) {
+  return name && name.startsWith("batch_");
+}
+
+function _mergeResults(primaryText, additionalTexts) {
+  try {
+    const primary = JSON.parse(primaryText);
+    if (!primary || !primary.ok) return primaryText;
+
+    for (const addText of additionalTexts) {
+      try {
+        const additional = JSON.parse(addText);
+        if (!additional || !additional.ok) continue;
+
+        if (Array.isArray(primary.results) && Array.isArray(additional.results)) {
+          const existingPaths = new Set(
+            primary.results.map(r => `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`)
+          );
+          for (const r of additional.results) {
+            const key = `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`;
+            if (!existingPaths.has(key)) {
+              primary.results.push(r);
+              existingPaths.add(key);
+            }
+          }
+        }
+
+        if (typeof primary.total === "number" && typeof additional.total === "number") {
+          primary.total = primary.results ? primary.results.length : primary.total + additional.total;
+        }
+        if (typeof primary.count === "number" && typeof additional.count === "number") {
+          primary.count = primary.results ? primary.results.length : primary.count + additional.count;
+        }
+      } catch (_) {}
+    }
+
+    if (Array.isArray(primary.results) && primary.results.length > 1) {
+      primary.results.sort((a, b) => (b.score || 0) - (a.score || 0));
+    }
+
+    const originalLimit = primary._original_limit;
+    if (originalLimit && Array.isArray(primary.results) && primary.results.length > originalLimit) {
+      primary.results = primary.results.slice(0, originalLimit);
+      if (typeof primary.total === "number") primary.total = primary.results.length;
+      if (typeof primary.count === "number") primary.count = primary.results.length;
+    }
+
+    primary._cross_collection = true;
+    return JSON.stringify(primary);
+  } catch (_) {
+    return primaryText;
+  }
+}
+
+function _mergeBatchResults(primaryText, additionalTexts) {
+  try {
+    const primary = JSON.parse(primaryText);
+    if (!primary || !primary.ok || !Array.isArray(primary.results)) return primaryText;
+
+    for (const addText of additionalTexts) {
+      try {
+        const additional = JSON.parse(addText);
+        if (!additional || !additional.ok || !Array.isArray(additional.results)) continue;
+
+        for (let i = 0; i < primary.results.length && i < additional.results.length; i++) {
+          const pItem = primary.results[i];
+          const aItem = additional.results[i];
+          if (!pItem || !aItem) continue;
+
+          const pInner = pItem.result || pItem;
+          const aInner = aItem.result || aItem;
+
+          if (Array.isArray(pInner.results) && Array.isArray(aInner.results)) {
+            const existingPaths = new Set(
+              pInner.results.map(r => `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`)
+            );
+            for (const r of aInner.results) {
+              const key = `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`;
+              if (!existingPaths.has(key)) {
+                pInner.results.push(r);
+                existingPaths.add(key);
+              }
+            }
+            if (pInner.results.length > 1) {
+              pInner.results.sort((a, b) => (b.score || 0) - (a.score || 0));
+            }
+            if (typeof pInner.total === "number") pInner.total = pInner.results.length;
+            if (typeof pInner.count === "number") pInner.count = pInner.results.length;
+          }
+        }
+      } catch (_) {}
+    }
+
+    primary._cross_collection = true;
+    return JSON.stringify(primary);
+  } catch (_) {
+    return primaryText;
+  }
+}
+
 function loadConfig(startDir) {
   try {
     let dir = startDir;