@liendev/lien 0.28.1 → 0.29.0

package/dist/index.js

@@ -8745,6 +8745,91 @@ function wrapToolHandler(schema, handler) {
   };
 }
 
+// src/mcp/utils/metadata-shaper.ts
+var FIELD_ALLOWLISTS = {
+  semantic_search: /* @__PURE__ */ new Set([
+    "language",
+    "type",
+    "symbolName",
+    "symbolType",
+    "signature",
+    "parentClass",
+    "parameters",
+    "exports",
+    "repoId"
+  ]),
+  find_similar: /* @__PURE__ */ new Set([
+    "language",
+    "type",
+    "symbolName",
+    "symbolType",
+    "signature",
+    "parentClass",
+    "parameters",
+    "exports"
+  ]),
+  get_files_context: /* @__PURE__ */ new Set([
+    "language",
+    "type",
+    "symbolName",
+    "symbolType",
+    "signature",
+    "parentClass",
+    "parameters",
+    "exports",
+    "imports",
+    "importedSymbols",
+    "callSites",
+    "symbols"
+  ]),
+  list_functions: /* @__PURE__ */ new Set([
+    "language",
+    "type",
+    "symbolName",
+    "symbolType",
+    "signature",
+    "parentClass",
+    "parameters",
+    "exports",
+    "symbols"
+  ])
+};
+function deduplicateResults(results) {
+  const seen = /* @__PURE__ */ new Set();
+  return results.filter((r) => {
+    const key = JSON.stringify([r.metadata.repoId ?? "", r.metadata.file, r.metadata.startLine, r.metadata.endLine]);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function pickMetadata(metadata, allowlist) {
+  const result = {
+    file: metadata.file,
+    startLine: metadata.startLine,
+    endLine: metadata.endLine
+  };
+  const out = result;
+  for (const key of allowlist) {
+    if (key === "file" || key === "startLine" || key === "endLine") continue;
+    if (metadata[key] !== void 0) {
+      out[key] = metadata[key];
+    }
+  }
+  return result;
+}
+function shapeResultMetadata(result, tool) {
+  return {
+    content: result.content,
+    metadata: pickMetadata(result.metadata, FIELD_ALLOWLISTS[tool]),
+    score: result.score,
+    relevance: result.relevance
+  };
+}
+function shapeResults(results, tool) {
+  return results.map((r) => shapeResultMetadata(r, tool));
+}
+
 // src/mcp/handlers/semantic-search.ts
 import { QdrantDB } from "@liendev/core";
 function groupResultsByRepo(results) {
@@ -8780,15 +8865,31 @@ async function handleSemanticSearch(args, ctx) {
         results = await vectorDB.search(queryEmbedding, limit, query);
         log(`Found ${results.length} results`);
       }
+      results = deduplicateResults(results);
+      const notes = [];
+      if (crossRepoFallback) {
+        notes.push("Cross-repo search requires Qdrant backend. Fell back to single-repo search.");
+      }
+      if (results.length > 0 && results.every((r) => r.relevance === "not_relevant")) {
+        notes.push("No relevant matches found.");
+        log("Returning 0 results (all not_relevant)");
+        return {
+          indexInfo: getIndexMetadata(),
+          results: [],
+          note: notes.join(" ")
+        };
+      }
+      log(`Returning ${results.length} results`);
+      const shaped = shapeResults(results, "semantic_search");
       const response = {
         indexInfo: getIndexMetadata(),
-        results
+        results: shaped
       };
       if (crossRepo && vectorDB instanceof QdrantDB) {
-        response.groupedByRepo = groupResultsByRepo(results);
+        response.groupedByRepo = groupResultsByRepo(shaped);
       }
-      if (crossRepoFallback) {
-        response.note = "Cross-repo search requires Qdrant backend. Fell back to single-repo search.";
+      if (notes.length > 0) {
+        response.note = notes.join(" ");
       }
       return response;
     }
@@ -8820,6 +8921,12 @@ async function handleFindSimilar(args, ctx) {
       const limit = validatedArgs.limit ?? 5;
       const extraLimit = limit + 10;
       let results = await vectorDB.search(codeEmbedding, extraLimit, validatedArgs.code);
+      results = deduplicateResults(results);
+      const inputCode = validatedArgs.code.trim();
+      results = results.filter((r) => {
+        if (r.score >= 0.1) return true;
+        return r.content.trim() !== inputCode;
+      });
       const filtersApplied = { prunedLowRelevance: 0 };
       if (validatedArgs.language) {
         filtersApplied.language = validatedArgs.language;
@@ -8836,7 +8943,7 @@ async function handleFindSimilar(args, ctx) {
       const hasFilters = filtersApplied.language || filtersApplied.pathHint || filtersApplied.prunedLowRelevance > 0;
       return {
         indexInfo: getIndexMetadata(),
-        results: finalResults,
+        results: shapeResults(finalResults, "find_similar"),
         ...hasFilters && { filtersApplied }
       };
     }
@@ -9044,18 +9151,26 @@ function buildScanLimitNote(hitScanLimit) {
   return hitScanLimit ? "Scanned 10,000 chunks (limit reached). Test associations may be incomplete for large codebases." : void 0;
 }
 function buildSingleFileResponse(filepath, filesData, indexInfo, note) {
+  const data = filesData[filepath];
   return {
     indexInfo,
     file: filepath,
-    chunks: filesData[filepath].chunks,
-    testAssociations: filesData[filepath].testAssociations,
+    chunks: shapeResults(data.chunks, "get_files_context"),
+    testAssociations: data.testAssociations,
     ...note && { note }
   };
 }
 function buildMultiFileResponse(filesData, indexInfo, note) {
+  const shaped = {};
+  for (const [filepath, data] of Object.entries(filesData)) {
+    shaped[filepath] = {
+      chunks: shapeResults(data.chunks, "get_files_context"),
+      testAssociations: data.testAssociations
+    };
+  }
   return {
     indexInfo,
-    files: filesData,
+    files: shaped,
     ...note && { note }
   };
 }
@@ -9160,11 +9275,12 @@ async function handleListFunctions(args, ctx) {
         log(`Symbol query failed: ${error}`);
         queryResult = await performContentScan(vectorDB, validatedArgs, log);
       }
-      log(`Found ${queryResult.results.length} matches using ${queryResult.method} method`);
+      const dedupedResults = deduplicateResults(queryResult.results);
+      log(`Found ${dedupedResults.length} matches using ${queryResult.method} method`);
       return {
         indexInfo: getIndexMetadata(),
         method: queryResult.method,
-        results: queryResult.results,
+        results: shapeResults(dedupedResults, "list_functions"),
         note: queryResult.method === "content" ? 'Using content search. Run "lien reindex" to enable faster symbol-based queries.' : void 0
       };
     }