@context-engine-bridge/context-engine-mcp-bridge 0.0.30 → 0.0.31

package/package.json

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

package/src/mcpServer.js

@@ -51,6 +51,80 @@ function _readLspConnection() {
   return _cacheNull();
 }
 
+const _LSP_ENRICHABLE_TOOLS = new Set([
+  "batch_search", "batch_symbol_graph", "batch_graph_query",
+  "repo_search", "repo_search_compat", "symbol_graph", "search",
+  "code_search", "context_search", "search_tests_for",
+  "search_config_for", "search_callers_for", "search_importers_for",
+]);
+
+function _extractPaths(obj, paths, depth = 0) {
+  if (!obj || typeof obj !== "object" || depth > 20) return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) _extractPaths(item, paths, depth + 1);
+    return;
+  }
+  if (typeof obj.path === "string" && (obj.path.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(obj.path))) paths.add(obj.path);
+  for (const [key, val] of Object.entries(obj)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    if (val && typeof val === "object") _extractPaths(val, paths, depth + 1);
+  }
+}
+
+function _callLspHandler(port, secret, operation, params) {
+  const postData = JSON.stringify(params);
+  return new Promise((resolve) => {
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port: parseInt(port, 10),
+      path: `/lsp/${operation}`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(postData),
+        ...(secret ? { "x-lsp-handler-token": secret } : {}),
+      },
+      timeout: 3000,
+    }, (res) => {
+      let data = "";
+      let exceeded = false;
+      const MAX_RESP = 5 * 1024 * 1024;
+      res.on("data", chunk => {
+        if (exceeded) return;
+        data += chunk;
+        if (data.length > MAX_RESP) { exceeded = true; req.destroy(); resolve(null); }
+      });
+      res.on("end", () => { if (!exceeded) { try { resolve(JSON.parse(data)); } catch { resolve(null); } } });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => { req.destroy(); resolve(null); });
+    req.write(postData);
+    req.end();
+  });
+}
+
+async function _enrichWithLsp(result, lspConn) {
+  try {
+    if (!Array.isArray(result?.content)) return result;
+    const textBlock = result.content.find(c => c.type === "text");
+    if (!textBlock?.text) return result;
+    let parsed;
+    try { parsed = JSON.parse(textBlock.text); } catch { return result; }
+    if (!parsed.ok) return result;
+    const paths = new Set();
+    _extractPaths(parsed, paths);
+    if (paths.size === 0) return result;
+    const diag = await _callLspHandler(lspConn.port, lspConn.secret, "diagnostics_recent", { paths: [...paths] });
+    if (!diag?.ok || !diag.files || diag.total === 0) return result;
+    parsed._lsp = { diagnostics: diag.files, total: diag.total };
+    textBlock.text = JSON.stringify(parsed);
+    return result;
+  } catch (err) {
+    debugLog("[ctxce] LSP enrichment failed: " + String(err));
+    return result;
+  }
+}
+
 function debugLog(message) {
   try {
     const text = typeof message === "string" ? message : String(message);
@@ -839,6 +913,16 @@ async function createBridgeServer(options) {
 
     const lspAvailable = !!_readLspConnection();
     if (lspAvailable) {
+      const lspProp = {
+        type: "boolean",
+        description: "When true, auto-enrich results with live LSP diagnostics (errors/warnings) for files in the response. Zero extra tool calls needed.",
+      };
+      for (const tool of tools) {
+        if (_LSP_ENRICHABLE_TOOLS.has(tool.name) && tool.inputSchema?.properties) {
+          tool.inputSchema = { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, include_lsp: lspProp } };
+        }
+      }
+
       const pathProp = { type: "string", description: "Absolute file path" };
       const lineProp = { type: "integer", description: "0-based line" };
       const charProp = { type: "integer", description: "0-based column" };
@@ -920,6 +1004,13 @@ async function createBridgeServer(options) {
     const name = params.name;
     let args = params.arguments;
 
+    let includeLsp = false;
+    if (args && typeof args === "object" && args.include_lsp === true && _LSP_ENRICHABLE_TOOLS.has(name)) {
+      includeLsp = true;
+      const { include_lsp: _stripped, ...rest } = args;
+      args = rest;
+    }
+
     debugLog(`[ctxce] tools/call: ${name || "<no-name>"}`);
 
     // Refresh session before each call; re-init clients if session changes.
@@ -985,9 +1076,15 @@ async function createBridgeServer(options) {
             timeout: 15000,
           }, (res) => {
             let data = "";
-            res.on("data", chunk => { data += chunk; });
+            let exceeded = false;
+            const MAX_RESP = 5 * 1024 * 1024;
+            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" }); }
+            });
             res.on("end", () => {
-              try { resolve(JSON.parse(data)); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); }
+              if (!exceeded) { try { resolve(JSON.parse(data)); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); } }
             });
           });
           req.on("error", reject);
@@ -997,7 +1094,9 @@ async function createBridgeServer(options) {
         });
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       } catch (err) {
-        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `LSP proxy error: ${err.message || String(err)}` }) }] };
+        debugLog("[ctxce] LSP proxy error: " + String(err));
+        const safeMsg = (err && err.code) ? `LSP proxy error: ${err.code}` : "LSP proxy error: request failed";
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: safeMsg }) }] };
       }
     }
 
@@ -1029,7 +1128,10 @@ async function createBridgeServer(options) {
           undefined,
           { timeout: timeoutMs },
         );
-        return maybeRemapToolResult(name, result, workspace);
+        let finalResult = maybeRemapToolResult(name, result, workspace);
+        const lspConn = includeLsp && _readLspConnection();
+        if (lspConn) finalResult = await _enrichWithLsp(finalResult, lspConn);
+        return finalResult;
       } catch (err) {
         lastError = err;