@liendev/lien 0.28.0 → 0.29.0

package/dist/index.js

@@ -8475,7 +8475,7 @@ var NEVER = INVALID;
 // src/mcp/schemas/search.schema.ts
 var SemanticSearchSchema = external_exports.object({
   query: external_exports.string().min(3, "Query must be at least 3 characters").max(500, "Query too long (max 500 characters)").describe(
-    "Natural language description of what you're looking for.\n\nUse full sentences describing functionality, not exact names.\n\nGood examples:\n  - 'handles user authentication'\n  - 'validates email format'\n  - 'processes payment transactions'\n\nBad examples:\n  - 'auth' (too vague)\n  - 'validateEmail' (use grep for exact names)"
+    "Natural language description of what you're looking for.\n\nUse full sentences describing functionality, not exact names.\n\nGood examples:\n  - 'How does the code handle user authentication?'\n  - 'Where are email addresses validated?'\n  - 'How are payment transactions processed?'\n\nBad examples:\n  - 'auth' (too vague)\n  - 'validateEmail' (use grep for exact names)"
   ),
   limit: external_exports.number().int().min(1, "Limit must be at least 1").max(50, "Limit cannot exceed 50").default(5).describe(
     "Number of results to return.\n\nDefault: 5\nIncrease to 10-15 for broad exploration."
@@ -8570,8 +8570,10 @@ var tools = [
     `Search codebase by MEANING, not text. Complements grep - use this for discovery and understanding, grep for exact matches.
 
 Examples:
-- "Where is authentication handled?" \u2192 semantic_search({ query: "handles user authentication" })
-- "How does payment work?" \u2192 semantic_search({ query: "processes payment transactions" })
+- "Where is authentication handled?" \u2192 semantic_search({ query: "How does the code handle user authentication?" })
+- "How does payment work?" \u2192 semantic_search({ query: "How are payment transactions processed and validated?" })
+
+IMPORTANT: Phrase queries as full questions starting with "How", "Where", "What", etc. Full questions produce significantly better relevance than keyword phrases.
 
 Use natural language describing what the code DOES, not function names. For exact string matching, use grep instead.
 
@@ -8743,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) {
@@ -8778,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;
     }
@@ -8818,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;
@@ -8834,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 }
       };
     }
@@ -9042,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 }
   };
 }
@@ -9158,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
       };
     }