@liendev/lien 0.28.1 → 0.29.1

package/dist/index.js

@@ -8745,6 +8745,111 @@ 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 cleanMetadataValue(key, value) {
+  if (value === void 0 || value === "") return null;
+  if (Array.isArray(value)) {
+    const filtered = value.filter((v) => v !== "");
+    return filtered.length > 0 ? filtered : null;
+  }
+  if (key === "symbols" && typeof value === "object" && value !== null) {
+    const symbols = value;
+    const filterArr = (arr) => Array.isArray(arr) ? arr.filter((s) => s !== "") : [];
+    const filtered = {
+      functions: filterArr(symbols.functions),
+      classes: filterArr(symbols.classes),
+      interfaces: filterArr(symbols.interfaces)
+    };
+    const hasAny = filtered.functions.length > 0 || filtered.classes.length > 0 || filtered.interfaces.length > 0;
+    return hasAny ? filtered : null;
+  }
+  return value;
+}
+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;
+    const cleaned = cleanMetadataValue(key, metadata[key]);
+    if (cleaned !== null) {
+      out[key] = cleaned;
+    }
+  }
+  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,17 +8885,28 @@ async function handleSemanticSearch(args, ctx) {
         results = await vectorDB.search(queryEmbedding, limit, query);
         log(`Found ${results.length} results`);
       }
-      const response = {
-        indexInfo: getIndexMetadata(),
-        results
-      };
-      if (crossRepo && vectorDB instanceof QdrantDB) {
-        response.groupedByRepo = groupResultsByRepo(results);
-      }
+      results = deduplicateResults(results);
+      const notes = [];
       if (crossRepoFallback) {
-        response.note = "Cross-repo search requires Qdrant backend. Fell back to single-repo search.";
+        notes.push("Cross-repo search requires Qdrant backend. Fell back to single-repo search.");
       }
-      return response;
+      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");
+      return {
+        indexInfo: getIndexMetadata(),
+        results: shaped,
+        ...crossRepo && vectorDB instanceof QdrantDB && { groupedByRepo: groupResultsByRepo(shaped) },
+        ...notes.length > 0 && { note: notes.join(" ") }
+      };
     }
   )(args);
 }
@@ -8820,6 +8936,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 +8958,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 }
       };
     }
@@ -8979,7 +9101,9 @@ async function findRelatedChunks(filepaths, fileChunksMap, ctx) {
     const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
     relatedChunksMap[index] = related.filter((r) => {
       const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
-      return chunkCanonical !== targetCanonical;
+      if (chunkCanonical === targetCanonical) return false;
+      if (r.metadata.language === "markdown") return false;
+      return true;
     });
   });
   return relatedChunksMap;
@@ -9015,23 +9139,15 @@ function findTestAssociations(filepaths, allChunks, ctx) {
     return Array.from(testFiles);
   });
 }
-function deduplicateChunks(fileChunks, relatedChunks, workspaceRoot) {
-  const seenChunks = /* @__PURE__ */ new Set();
-  return [...fileChunks, ...relatedChunks].filter((chunk) => {
-    const canonicalFile = getCanonicalPath(chunk.metadata.file, workspaceRoot);
-    const chunkId = `${canonicalFile}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
-    if (seenChunks.has(chunkId)) return false;
-    seenChunks.add(chunkId);
-    return true;
-  });
+function deduplicateChunks(fileChunks, relatedChunks) {
+  return deduplicateResults([...fileChunks, ...relatedChunks]);
 }
-function buildFilesData(filepaths, fileChunksMap, relatedChunksMap, testAssociationsMap, workspaceRoot) {
+function buildFilesData(filepaths, fileChunksMap, relatedChunksMap, testAssociationsMap) {
   const filesData = {};
   filepaths.forEach((filepath, i) => {
     const dedupedChunks = deduplicateChunks(
       fileChunksMap[i],
-      relatedChunksMap[i] || [],
-      workspaceRoot
+      relatedChunksMap[i] || []
     );
     filesData[filepath] = {
       chunks: dedupedChunks,
@@ -9044,18 +9160,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 }
   };
 }
@@ -9101,8 +9225,7 @@ async function handleGetFilesContext(args, ctx) {
         filepaths,
         fileChunksMap,
         relatedChunksMap,
-        testAssociationsMap,
-        workspaceRoot
+        testAssociationsMap
       );
       const totalChunks = Object.values(filesData).reduce(
         (sum, f) => sum + f.chunks.length,
@@ -9160,11 +9283,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
       };
     }
@@ -9680,7 +9804,11 @@ async function handleGetComplexity(args, ctx) {
         threshold,
         top ?? 10
       );
-      const response = {
+      const note = buildCrossRepoFallbackNote(fallback);
+      if (note) {
+        log("Warning: crossRepo=true requires Qdrant backend. Falling back to single-repo analysis.", "warning");
+      }
+      return {
         indexInfo: getIndexMetadata(),
         summary: {
           filesAnalyzed: report.summary.filesAnalyzed,
@@ -9689,17 +9817,12 @@ async function handleGetComplexity(args, ctx) {
           violationCount: violations.length,
           bySeverity
         },
-        violations: topViolations
+        violations: topViolations,
+        ...crossRepo && !fallback && allChunks.length > 0 && {
+          groupedByRepo: groupViolationsByRepo(topViolations, allChunks)
+        },
+        ...note && { note }
       };
-      if (crossRepo && !fallback && allChunks.length > 0) {
-        response.groupedByRepo = groupViolationsByRepo(topViolations, allChunks);
-      }
-      const note = buildCrossRepoFallbackNote(fallback);
-      if (note) {
-        log("Warning: crossRepo=true requires Qdrant backend. Falling back to single-repo analysis.", "warning");
-        response.note = note;
-      }
-      return response;
     }
   )(args);
 }