@vheins/local-memory-mcp 0.9.5 → 0.9.8

package/dist/{chunk-H2NOOJCN.js → chunk-CSEGUZWJ.js}

@@ -3,8 +3,8 @@ import { fileURLToPath } from "url";
 import path from "path";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var pkgVersion = "0.1.0";
-if ("0.9.5") {
-  pkgVersion = "0.9.5";
+if ("0.9.8") {
+  pkgVersion = "0.9.8";
 } else {
   let searchDir = __dirname;
   for (let i = 0; i < 5; i++) {

package/dist/dashboard/server.js

@@ -10,7 +10,7 @@ import {
   createFileSink,
   listResources,
   logger
-} from "../chunk-H2NOOJCN.js";
+} from "../chunk-CSEGUZWJ.js";
 
 // src/dashboard/server.ts
 import express from "express";

package/dist/mcp/server.js

@@ -55,7 +55,7 @@ import {
   toContextSlug,
   updateSessionFromInitialize,
   updateSessionRoots
-} from "../chunk-H2NOOJCN.js";
+} from "../chunk-CSEGUZWJ.js";
 
 // src/mcp/server.ts
 import readline from "readline";
@@ -1901,10 +1901,63 @@ async function handleStandardStore(params, db2, vectors2) {
 
 // src/mcp/tools/standard.search.ts
 var HYBRID_WEIGHTS_STANDARD = {
-  similarity: 0.55,
-  vector: 0.35,
-  usage: 0.1
+  similarity: 0.4,
+  vector: 0.25,
+  keyword: 0.3,
+  usage: 0.05
 };
+function tokenizeSearchText(value) {
+  return value.toLowerCase().split(/[^a-z0-9]+/g).map((token) => token.trim()).filter((token) => token.length >= 2);
+}
+function scoreKeywordRelevance(query, standard) {
+  const queryTokens = Array.from(new Set(tokenizeSearchText(query)));
+  if (queryTokens.length === 0) return 0;
+  const titleText = standard.title.toLowerCase();
+  const contextText = standard.context.toLowerCase();
+  const tagText = standard.tags.join(" ").toLowerCase();
+  const stackText = standard.stack.join(" ").toLowerCase();
+  const contentText = standard.content.toLowerCase();
+  const queryPhrase = query.trim().toLowerCase();
+  let titleMatches = 0;
+  let contextMatches = 0;
+  let tagMatches = 0;
+  let stackMatches = 0;
+  let contentMatches = 0;
+  for (const token of queryTokens) {
+    if (titleText.includes(token)) titleMatches += 1;
+    if (contextText.includes(token)) contextMatches += 1;
+    if (tagText.includes(token)) tagMatches += 1;
+    if (stackText.includes(token)) stackMatches += 1;
+    if (contentText.includes(token)) contentMatches += 1;
+  }
+  const titleCoverage = titleMatches / queryTokens.length;
+  const contextCoverage = contextMatches / queryTokens.length;
+  const tagCoverage = tagMatches / queryTokens.length;
+  const stackCoverage = stackMatches / queryTokens.length;
+  const contentCoverage = contentMatches / queryTokens.length;
+  const exactPhraseBonus = queryPhrase.length >= 6 && (titleText.includes(queryPhrase) || contentText.includes(queryPhrase) || tagText.includes(queryPhrase)) ? 0.2 : 0;
+  return Math.min(
+    1,
+    titleCoverage * 0.45 + contextCoverage * 0.15 + tagCoverage * 0.15 + stackCoverage * 0.05 + contentCoverage * 0.2 + exactPhraseBonus
+  );
+}
+function collectMatchedTerms(query, standard) {
+  const queryTokens = Array.from(new Set(tokenizeSearchText(query)));
+  if (queryTokens.length === 0) return [];
+  const searchableFields = [
+    standard.title.toLowerCase(),
+    standard.context.toLowerCase(),
+    standard.tags.join(" ").toLowerCase(),
+    standard.stack.join(" ").toLowerCase(),
+    standard.content.toLowerCase()
+  ];
+  return queryTokens.filter((token) => searchableFields.some((field) => field.includes(token)));
+}
+function toConfidence(finalScore, keywordScore) {
+  if (finalScore >= 0.72 || keywordScore >= 0.85) return "high";
+  if (finalScore >= 0.42 || keywordScore >= 0.45) return "medium";
+  return "low";
+}
 async function handleStandardSearch(params, db2, vectors2) {
   const validated = StandardSearchSchema.parse(params);
   const searchQuery = expandQuery(validated.query || "", void 0);
@@ -1936,13 +1989,18 @@ async function handleStandardSearch(params, db2, vectors2) {
     if (similarityResults.length > 0) {
       scoredStandards = similarityResults.map((candidate) => {
         const vectorScore = vectorScoreMap.get(candidate.id) ?? 0;
+        const keywordScore = scoreKeywordRelevance(validated.query || "", candidate);
+        const matchedTerms = collectMatchedTerms(validated.query || "", candidate);
         const usageScore = Math.min(1, candidate.hit_count / 10);
-        const finalScore = candidate.similarity * HYBRID_WEIGHTS_STANDARD.similarity + vectorScore * HYBRID_WEIGHTS_STANDARD.vector + usageScore * HYBRID_WEIGHTS_STANDARD.usage;
+        const finalScore = candidate.similarity * HYBRID_WEIGHTS_STANDARD.similarity + vectorScore * HYBRID_WEIGHTS_STANDARD.vector + keywordScore * HYBRID_WEIGHTS_STANDARD.keyword + usageScore * HYBRID_WEIGHTS_STANDARD.usage;
         return {
           standard: candidate,
           similarityScore: candidate.similarity,
           vectorScore,
-          finalScore
+          keywordScore,
+          matchedTerms,
+          finalScore,
+          confidence: toConfidence(finalScore, keywordScore)
         };
       });
     } else if (vectorResults.length > 0) {
@@ -1951,43 +2009,58 @@ async function handleStandardSearch(params, db2, vectors2) {
       scoredStandards = vectorResults.flatMap((row) => {
         const standard = standardMap.get(row.id);
         if (!standard) return [];
+        const keywordScore = scoreKeywordRelevance(validated.query || "", standard);
+        const matchedTerms = collectMatchedTerms(validated.query || "", standard);
         const usageScore = Math.min(1, standard.hit_count / 10);
+        const finalScore = row.score * HYBRID_WEIGHTS_STANDARD.vector + keywordScore * HYBRID_WEIGHTS_STANDARD.keyword + usageScore * (1 - HYBRID_WEIGHTS_STANDARD.vector - HYBRID_WEIGHTS_STANDARD.keyword);
         return [
           {
             standard,
             similarityScore: 0,
             vectorScore: row.score,
-            finalScore: row.score * 0.9 + usageScore * 0.1
+            keywordScore,
+            matchedTerms,
+            finalScore,
+            confidence: toConfidence(finalScore, keywordScore)
           }
         ];
       });
     }
   } catch (error) {
     logger.warn("Standard vector search failed, using similarity only", { error: String(error) });
-    scoredStandards = similarityResults.map((candidate) => ({
-      standard: candidate,
-      similarityScore: candidate.similarity,
-      vectorScore: 0,
-      finalScore: candidate.similarity * 0.9 + Math.min(1, candidate.hit_count / 10) * 0.1
-    }));
+    scoredStandards = similarityResults.map((candidate) => {
+      const keywordScore = scoreKeywordRelevance(validated.query || "", candidate);
+      const matchedTerms = collectMatchedTerms(validated.query || "", candidate);
+      const finalScore = candidate.similarity * (HYBRID_WEIGHTS_STANDARD.similarity + HYBRID_WEIGHTS_STANDARD.vector * 0.5) + keywordScore * HYBRID_WEIGHTS_STANDARD.keyword + Math.min(1, candidate.hit_count / 10) * HYBRID_WEIGHTS_STANDARD.usage;
+      return {
+        standard: candidate,
+        similarityScore: candidate.similarity,
+        vectorScore: 0,
+        keywordScore,
+        matchedTerms,
+        finalScore,
+        confidence: toConfidence(finalScore, keywordScore)
+      };
+    });
   }
   scoredStandards.sort((a, b) => b.finalScore - a.finalScore);
   const threshold = scoredStandards.length <= 5 ? 0.08 : 0.2;
-  let results = scoredStandards.filter((candidate) => candidate.finalScore >= threshold).map((candidate) => candidate.standard);
+  let results = scoredStandards.filter((candidate) => candidate.finalScore >= threshold);
   if (results.length === 0 && scoredStandards.length > 0) {
-    results = [scoredStandards[0].standard];
+    results = [scoredStandards[0]];
   }
   const paginatedResults = results.slice(validated.offset, validated.offset + validated.limit);
-  db2.standards.incrementHitCounts(paginatedResults.map((standard) => standard.id));
+  db2.standards.incrementHitCounts(paginatedResults.map(({ standard }) => standard.id));
   logger.info("[Tool] standard.search - searched coding standards", {
     resultCount: paginatedResults.length,
     stack: validated.stack,
     language: validated.language,
     context: validated.context,
-    version: validated.version
+    version: validated.version,
+    topConfidence: paginatedResults[0]?.confidence
   });
-  const COLUMNS = ["code", "id", "title", "context", "language", "scope", "tags", "updated_at"];
-  const rows = paginatedResults.map((standard) => [
+  const COLUMNS = ["code", "id", "title", "context", "language", "scope", "tags", "confidence", "score", "matched_terms", "updated_at"];
+  const rows = paginatedResults.map(({ standard, confidence, finalScore, matchedTerms }) => [
     standard.code ?? "-",
     standard.id,
     standard.title,
@@ -1995,18 +2068,21 @@ async function handleStandardSearch(params, db2, vectors2) {
     standard.language || "-",
     standard.is_global ? "global" : standard.repo || "-",
     standard.tags.join(", "),
+    confidence,
+    Number(finalScore.toFixed(3)),
+    matchedTerms.join(", "),
     standard.updated_at
   ]);
   let contentSummary;
   if (paginatedResults.length > 0) {
     const parts = [
       "Standards:",
-      "- title|context|language|scope",
+      "- code|confidence|matched_terms|title|context|language|scope",
       ...paginatedResults.map(
-        (standard) => `- ${standard.title}|${standard.context}|${standard.language || "-"}|${standard.is_global ? "global" : standard.repo || "-"}`
+        ({ standard, confidence, matchedTerms }) => `- ${standard.code ?? "-"}|${confidence}|${matchedTerms.join(", ")}|${standard.title}|${standard.context}|${standard.language || "-"}|${standard.is_global ? "global" : standard.repo || "-"}`
       ),
       "",
-      "Use standard-detail with id or code for full content."
+      "Use standard-detail with code for full content."
     ];
     contentSummary = parts.join("\n");
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vheins/local-memory-mcp",
-	"version": "0.9.5",
+	"version": "0.9.8",
 	"description": "MCP Local Memory Service for coding copilot agents",
 	"mcpName": "io.github.vheins/local-memory-mcp",
 	"type": "module",