@context-engine-bridge/context-engine-mcp-bridge 0.0.70 → 0.0.72

package/package.json

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

package/src/mcpServer.js

@@ -1262,10 +1262,6 @@ async function createBridgeServer(options) {
       debugLog(`[ctxce] Fan-out: ${name} across ${additionalCollections.length} additional collection(s): ${additionalCollections.join(", ")}`);
     }
 
-    if (shouldFanOut && args && typeof args === "object") {
-      args = { ...args, output_format: "json", compact: false };
-    }
-
     const timeoutMs = getBridgeToolTimeoutMs();
     const maxAttempts = getBridgeRetryAttempts();
     const retryDelayMs = getBridgeRetryDelayMs();
@@ -1868,8 +1864,10 @@ function _isBatchTool(name) {
 }
 
 function _unwrapSearchEnvelope(obj) {
-  if (obj && obj.result && typeof obj.result === "object" && obj.result.ok !== undefined) {
-    return obj.result;
+  if (obj && obj.result && typeof obj.result === "object") {
+    if (obj.result.ok !== undefined || Array.isArray(obj.result.results) || Array.isArray(obj.result.results_json)) {
+      return obj.result;
+    }
   }
   return obj;
 }
@@ -1880,10 +1878,34 @@ function _getResultsArray(obj) {
   return null;
 }
 
+function _parseToonResults(toonStr) {
+  if (typeof toonStr !== "string") return null;
+  try {
+    const lines = toonStr.split("\n");
+    const results = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      const parts = line.split(",");
+      if (parts.length < 4) continue;
+      const clean = s => (s || "").replace(/^["'\s]+|["'\s]+$/g, "");
+      results.push({
+        score: parseFloat(parts[0]) || 0,
+        path: clean(parts[1]),
+        symbol: clean(parts[2]),
+        start_line: parseInt(parts[3], 10) || 0,
+        end_line: parseInt(parts[4], 10) || 0,
+      });
+    }
+    return results.length > 0 ? results : null;
+  } catch (_) { return null; }
+}
+
 function _mergeResults(primaryText, additionalTexts) {
   try {
     const primary = JSON.parse(primaryText);
-    if (!primary || !primary.ok) return primaryText;
+    const _primaryHasData = primary && (primary.ok || Array.isArray(primary.results) || (primary.result && Array.isArray(primary.result.results)));
+    if (!_primaryHasData) return primaryText;
 
     const pInner = _unwrapSearchEnvelope(primary);
 
@@ -1892,7 +1914,8 @@ function _mergeResults(primaryText, additionalTexts) {
     for (const addText of additionalTexts) {
       try {
         const additional = JSON.parse(addText);
-        if (!additional || !additional.ok) {
+        const _addHasData = additional && (additional.ok || Array.isArray(additional.results) || (additional.result && Array.isArray(additional.result.results)));
+        if (!_addHasData) {
           _perCall.push({ ok: false, error: additional?.error || "not ok" });
           continue;
         }
@@ -1925,10 +1948,25 @@ function _mergeResults(primaryText, additionalTexts) {
             pInner.results_json = pResults;
           }
         } else if (!pResults && aResults) {
-          primary._merge_branch = "only_additional";
-          _totalAdded += aResults.length;
-          _perCall.push({ ok: true, a_len: aResults.length, added: aResults.length, branch: "only_additional" });
-          pInner.results_json = [...aResults];
+          const parsedToon = _parseToonResults(pInner.results);
+          if (parsedToon) {
+            primary._merge_branch = "toon_parsed";
+            const existingPaths = new Set(parsedToon.map(r => `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`));
+            let added = 0;
+            for (const r of aResults) {
+              const key = `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`;
+              if (!existingPaths.has(key)) { parsedToon.push(r); existingPaths.add(key); added++; }
+            }
+            parsedToon.sort((a, b) => (b.score || 0) - (a.score || 0));
+            _totalAdded += added;
+            _perCall.push({ ok: true, a_len: aResults.length, added, branch: "toon_parsed", before: parsedToon.length - added, after: parsedToon.length });
+            pInner.results_json = parsedToon;
+          } else {
+            primary._merge_branch = "only_additional";
+            _totalAdded += aResults.length;
+            _perCall.push({ ok: true, a_len: aResults.length, added: aResults.length, branch: "only_additional" });
+            pInner.results_json = [...aResults];
+          }
         } else {
           primary._merge_branch = "no_merge";
           _perCall.push({ ok: true, branch: "no_merge", p_type: pResults ? "array" : typeof pInner.results, a_type: aResults ? "array" : typeof aInner.results });
@@ -1979,37 +2017,51 @@ function _mergeResults(primaryText, additionalTexts) {
 function _mergeBatchResults(primaryText, additionalTexts) {
   try {
     const primary = JSON.parse(primaryText);
-    if (!primary || !primary.ok || !Array.isArray(primary.results)) return primaryText;
+    if (!primary || !primary.ok) return primaryText;
+    const pBatch = Array.isArray(primary.results) ? primary.results : Array.isArray(primary.batch_results) ? primary.batch_results : null;
+    if (!pBatch) return primaryText;
 
     for (const addText of additionalTexts) {
       try {
         const additional = JSON.parse(addText);
-        if (!additional || !additional.ok || !Array.isArray(additional.results)) continue;
+        if (!additional || !additional.ok) continue;
+        const aBatch = Array.isArray(additional.results) ? additional.results : Array.isArray(additional.batch_results) ? additional.batch_results : null;
+        if (!aBatch) continue;
 
-        for (let i = 0; i < primary.results.length && i < additional.results.length; i++) {
-          const pItem = primary.results[i];
-          const aItem = additional.results[i];
+        for (let i = 0; i < pBatch.length && i < aBatch.length; i++) {
+          const pItem = pBatch[i];
+          const aItem = aBatch[i];
           if (!pItem || !aItem) continue;
 
           const pInner = pItem.result || pItem;
           const aInner = aItem.result || aItem;
 
-          if (Array.isArray(pInner.results) && Array.isArray(aInner.results)) {
+          let pResults = Array.isArray(pInner.results) ? pInner.results : Array.isArray(pInner.results_json) ? pInner.results_json : null;
+          const aResults = Array.isArray(aInner.results) ? aInner.results : Array.isArray(aInner.results_json) ? aInner.results_json : null;
+
+          if (!pResults && typeof pInner.results === "string") {
+            pResults = _parseToonResults(pInner.results);
+          }
+
+          if (pResults && aResults) {
             const existingPaths = new Set(
-              pInner.results.map(r => `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`)
+              pResults.map(r => `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`)
             );
-            for (const r of aInner.results) {
+            for (const r of aResults) {
               const key = `${r.path || ""}:${r.start_line || 0}:${r.symbol || ""}`;
               if (!existingPaths.has(key)) {
-                pInner.results.push(r);
+                pResults.push(r);
                 existingPaths.add(key);
               }
             }
-            if (pInner.results.length > 1) {
-              pInner.results.sort((a, b) => (b.score || 0) - (a.score || 0));
+            if (pResults.length > 1) {
+              pResults.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;
+            pInner.results_json = pResults;
+            if (typeof pInner.total === "number") pInner.total = pResults.length;
+            if (typeof pInner.count === "number") pInner.count = pResults.length;
+          } else if (!pResults && aResults) {
+            pInner.results_json = [...aResults];
           }
         }
       } catch (_) {}