@velvetmonkey/flywheel-memory 2.0.122 → 2.0.124

package/dist/index.js

@@ -6314,7 +6314,11 @@ var indexProgress = { parsed: 0, total: 0 };
 var indexError = null;
 function getIndexState() {
   const scope = getActiveScopeOrNull();
-  return scope ? scope.indexState : indexState;
+  if (scope) {
+    if (scope.indexState === "building" && indexState === "ready") return "ready";
+    return scope.indexState;
+  }
+  return indexState;
 }
 function getIndexProgress() {
   return { ...indexProgress };
@@ -10720,7 +10724,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
 import { z as z4 } from "zod";
 init_embeddings();
 import {
-  searchEntities,
+  searchEntities as searchEntities2,
   searchEntitiesPrefix
 } from "@velvetmonkey/vault-core";
 
@@ -10729,7 +10733,6 @@ import {
   getEntityByName as getEntityByName2
 } from "@velvetmonkey/vault-core";
 var TOP_LINKS = 10;
-var RECALL_TOP_LINKS = 5;
 function recencyDecay(modifiedDate) {
   if (!modifiedDate) return 0.5;
   const daysSince = (Date.now() - modifiedDate.getTime()) / (1e3 * 60 * 60 * 24);
@@ -10819,6 +10822,63 @@ function rankBacklinks(backlinks, notePath, index, stateDb2, maxLinks = TOP_LINK
     return out;
   }).sort((a, b) => (b.weight ?? 1) - (a.weight ?? 1)).slice(0, maxLinks);
 }
+var COMPACT_OUTLINK_NAMES = 10;
+function enrichResultCompact(result, index, stateDb2, opts) {
+  const note = index.notes.get(result.path);
+  const normalizedPath = result.path.toLowerCase().replace(/\.md$/, "");
+  const backlinks = index.backlinks.get(normalizedPath) || [];
+  const enriched = {
+    path: result.path,
+    title: result.title
+  };
+  if (result.snippet) {
+    enriched.snippet = result.snippet;
+  } else {
+    const preview = getContentPreview(result.path);
+    if (preview) enriched.snippet = preview;
+  }
+  if (note) {
+    enriched.backlink_count = backlinks.length;
+    enriched.modified = note.modified.toISOString();
+    if (note.tags.length > 0) enriched.tags = note.tags;
+    if (note.outlinks.length > 0) {
+      enriched.outlink_names = getOutlinkNames(note.outlinks, result.path, index, stateDb2, COMPACT_OUTLINK_NAMES);
+    }
+  }
+  if (stateDb2) {
+    try {
+      const entity = getEntityByName2(stateDb2, result.title);
+      if (entity) {
+        enriched.category = entity.category;
+        enriched.hub_score = entity.hubScore;
+        if (!enriched.snippet && entity.description) {
+          enriched.snippet = entity.description;
+        }
+      }
+    } catch {
+    }
+  }
+  if (opts?.via) enriched.via = opts.via;
+  if (opts?.hop) enriched.hop = opts.hop;
+  return enriched;
+}
+function getOutlinkNames(outlinks, notePath, index, stateDb2, max) {
+  const weightMap = /* @__PURE__ */ new Map();
+  if (stateDb2) {
+    try {
+      const rows = stateDb2.db.prepare(
+        "SELECT target, weight, weight_updated_at FROM note_links WHERE note_path = ?"
+      ).all(notePath);
+      for (const row of rows) {
+        const daysSince = row.weight_updated_at ? (Date.now() - row.weight_updated_at) / (1e3 * 60 * 60 * 24) : 0;
+        const decay = Math.max(0.1, 1 - daysSince / 180);
+        weightMap.set(row.target, row.weight * decay);
+      }
+    } catch {
+    }
+  }
+  return outlinks.map((l) => ({ name: l.target, weight: weightMap.get(l.target.toLowerCase()) ?? 1 })).sort((a, b) => b.weight - a.weight).slice(0, max).map((l) => l.name);
+}
 function enrichResult(result, index, stateDb2) {
   const note = index.notes.get(result.path);
   const normalizedPath = result.path.toLowerCase().replace(/\.md$/, "");
@@ -10886,7 +10946,7 @@ function enrichResultLight(result, index, stateDb2) {
   }
   return enriched;
 }
-function enrichEntityResult(entityName, stateDb2, index) {
+function enrichEntityCompact(entityName, stateDb2, index) {
   const enriched = {};
   if (stateDb2) {
     try {
@@ -10908,36 +10968,27 @@ function enrichEntityResult(entityName, stateDb2, index) {
       const backlinks = index.backlinks.get(normalizedPath) || [];
       enriched.backlink_count = backlinks.length;
       if (note) {
-        enriched.outlink_count = note.outlinks.length;
         if (note.tags.length > 0) enriched.tags = note.tags;
-        if (backlinks.length > 0) {
-          enriched.top_backlinks = rankBacklinks(backlinks, entityPath, index, stateDb2, RECALL_TOP_LINKS);
-        }
         if (note.outlinks.length > 0) {
-          enriched.top_outlinks = rankOutlinks(note.outlinks, entityPath, index, stateDb2, RECALL_TOP_LINKS);
+          enriched.outlink_names = getOutlinkNames(note.outlinks, entityPath, index, stateDb2, COMPACT_OUTLINK_NAMES);
         }
       }
     }
   }
   return enriched;
 }
-function enrichNoteResult(notePath, stateDb2, index) {
+function enrichNoteCompact(notePath, stateDb2, index) {
   const enriched = {};
   if (!index) return enriched;
   const note = index.notes.get(notePath);
   if (!note) return enriched;
   const normalizedPath = notePath.toLowerCase().replace(/\.md$/, "");
   const backlinks = index.backlinks.get(normalizedPath) || [];
-  enriched.frontmatter = note.frontmatter;
   if (note.tags.length > 0) enriched.tags = note.tags;
   enriched.backlink_count = backlinks.length;
-  enriched.outlink_count = note.outlinks.length;
   enriched.modified = note.modified.toISOString();
-  if (backlinks.length > 0) {
-    enriched.top_backlinks = rankBacklinks(backlinks, notePath, index, stateDb2, RECALL_TOP_LINKS);
-  }
   if (note.outlinks.length > 0) {
-    enriched.top_outlinks = rankOutlinks(note.outlinks, notePath, index, stateDb2, RECALL_TOP_LINKS);
+    enriched.outlink_names = getOutlinkNames(note.outlinks, notePath, index, stateDb2, COMPACT_OUTLINK_NAMES);
   }
   if (stateDb2) {
     try {
@@ -10952,8 +11003,132 @@ function enrichNoteResult(notePath, stateDb2, index) {
   return enriched;
 }
 
+// src/core/read/multihop.ts
+import { getEntityByName as getEntityByName3, searchEntities } from "@velvetmonkey/vault-core";
+var DEFAULT_CONFIG2 = {
+  maxParents: 10,
+  maxHops: 2,
+  maxOutlinksPerHop: 10,
+  maxBackfill: 10
+};
+function multiHopBackfill(primaryResults, index, stateDb2, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
+  const seen = new Set(primaryResults.map((r) => r.path).filter(Boolean));
+  const candidates = [];
+  const hop1Results = [];
+  for (const primary of primaryResults.slice(0, cfg.maxParents)) {
+    const primaryPath = primary.path;
+    if (!primaryPath) continue;
+    const note = index.notes.get(primaryPath);
+    if (!note) continue;
+    for (const outlink of note.outlinks.slice(0, cfg.maxOutlinksPerHop)) {
+      const targetPath = index.entities.get(outlink.target.toLowerCase());
+      if (!targetPath || seen.has(targetPath)) continue;
+      seen.add(targetPath);
+      const targetNote = index.notes.get(targetPath);
+      const title = targetNote?.title ?? outlink.target;
+      hop1Results.push({ path: targetPath, title, via: primaryPath });
+    }
+  }
+  for (const h1 of hop1Results) {
+    const enriched = enrichResultCompact(
+      { path: h1.path, title: h1.title },
+      index,
+      stateDb2,
+      { via: h1.via, hop: 1 }
+    );
+    const score = scoreCandidate(h1.path, index, stateDb2);
+    candidates.push({ result: enriched, score });
+  }
+  if (cfg.maxHops >= 2) {
+    for (const h1 of hop1Results) {
+      const note = index.notes.get(h1.path);
+      if (!note) continue;
+      for (const outlink of note.outlinks.slice(0, cfg.maxOutlinksPerHop)) {
+        const targetPath = index.entities.get(outlink.target.toLowerCase());
+        if (!targetPath || seen.has(targetPath)) continue;
+        seen.add(targetPath);
+        const targetNote = index.notes.get(targetPath);
+        const title = targetNote?.title ?? outlink.target;
+        const enriched = enrichResultCompact(
+          { path: targetPath, title },
+          index,
+          stateDb2,
+          { via: h1.path, hop: 2 }
+        );
+        const score = scoreCandidate(targetPath, index, stateDb2);
+        candidates.push({ result: enriched, score });
+      }
+    }
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  return candidates.slice(0, cfg.maxBackfill).map((c) => c.result);
+}
+function scoreCandidate(path33, index, stateDb2) {
+  const note = index.notes.get(path33);
+  const decay = recencyDecay(note?.modified);
+  let hubScore = 1;
+  if (stateDb2) {
+    try {
+      const title = note?.title ?? path33.replace(/\.md$/, "").split("/").pop() ?? "";
+      const entity = getEntityByName3(stateDb2, title);
+      if (entity) hubScore = entity.hubScore ?? 1;
+    } catch {
+    }
+  }
+  return hubScore * decay;
+}
+function extractExpansionTerms(results, originalQuery, index) {
+  const queryLower = originalQuery.toLowerCase();
+  const terms = /* @__PURE__ */ new Set();
+  for (const r of results.slice(0, 5)) {
+    const outlinks = r.outlink_names;
+    if (outlinks) {
+      for (const name of outlinks) {
+        if (!queryLower.includes(name.toLowerCase()) && index.entities.has(name.toLowerCase())) {
+          terms.add(name);
+        }
+      }
+    }
+    const snippet = r.snippet;
+    if (snippet) {
+      const matches = snippet.match(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
+      if (matches) {
+        for (const wl of matches) {
+          const name = wl.replace(/\[\[|\]\]/g, "").split("|")[0];
+          if (!queryLower.includes(name.toLowerCase()) && index.entities.has(name.toLowerCase())) {
+            terms.add(name);
+          }
+        }
+      }
+    }
+  }
+  return Array.from(terms).slice(0, 10);
+}
+function expandQuery(expansionTerms, primaryResults, index, stateDb2) {
+  if (!stateDb2 || expansionTerms.length === 0) return [];
+  const seen = new Set(primaryResults.map((r) => r.path).filter(Boolean));
+  const results = [];
+  for (const term of expansionTerms) {
+    try {
+      const entities = searchEntities(stateDb2, term, 3);
+      for (const entity of entities) {
+        if (!entity.path || seen.has(entity.path)) continue;
+        seen.add(entity.path);
+        results.push(enrichResultCompact(
+          { path: entity.path, title: entity.name },
+          index,
+          stateDb2,
+          { via: "query_expansion" }
+        ));
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+
 // src/tools/read/query.ts
-init_wikilinkFeedback();
 function matchesFrontmatter(note, where) {
   for (const [key, value] of Object.entries(where)) {
     const noteValue = note.frontmatter[key];
@@ -11134,7 +11309,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
         const stateDbEntity = getStateDb2();
         if (stateDbEntity) {
           try {
-            entityResults = searchEntities(stateDbEntity, query, limit);
+            entityResults = searchEntities2(stateDbEntity, query, limit);
           } catch {
           }
         }
@@ -11206,46 +11381,22 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
             scored.sort((a, b) => b.rrf_score - a.rrf_score);
             const filtered = applyFolderFilter(scored);
             const stateDb2 = getStateDb2();
-            const results = filtered.slice(0, limit).map((item, i) => ({
-              ...(i < detailN ? enrichResult : enrichResultLight)({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
+            const results2 = filtered.slice(0, limit).map((item) => ({
+              ...enrichResultCompact({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
               rrf_score: item.rrf_score,
               in_fts5: item.in_fts5,
               in_semantic: item.in_semantic,
               in_entity: item.in_entity
             }));
-            if (stateDb2 && results.length < limit) {
-              const existingPaths = new Set(results.map((r) => r.path));
-              const backfill = [];
-              for (const r of results.slice(0, 3)) {
-                const rPath = r.path;
-                if (!rPath) continue;
-                try {
-                  const outlinks = getStoredNoteLinks(stateDb2, rPath);
-                  for (const target of outlinks) {
-                    const entityRow = stateDb2.db.prepare(
-                      "SELECT path FROM entities WHERE name_lower = ?"
-                    ).get(target);
-                    if (entityRow?.path && !existingPaths.has(entityRow.path)) {
-                      existingPaths.add(entityRow.path);
-                      backfill.push({
-                        ...enrichResultLight({ path: entityRow.path, title: target }, index, stateDb2),
-                        rrf_score: 0,
-                        in_fts5: false,
-                        in_semantic: false,
-                        in_entity: false
-                      });
-                    }
-                  }
-                } catch {
-                }
-              }
-              results.push(...backfill.slice(0, limit - results.length));
-            }
+            const hopResults2 = multiHopBackfill(results2, index, stateDb2, { maxBackfill: limit });
+            const expansionTerms2 = extractExpansionTerms(results2, query, index);
+            const expansionResults2 = expandQuery(expansionTerms2, [...results2, ...hopResults2], index, stateDb2);
+            results2.push(...hopResults2, ...expansionResults2);
             return { content: [{ type: "text", text: JSON.stringify({
               method: "hybrid",
               query,
               total_results: filtered.length,
-              results
+              results: results2
             }, null, 2) }] };
           } catch (err) {
             console.error("[Semantic] Hybrid search failed, falling back to FTS5:", err instanceof Error ? err.message : err);
@@ -11262,49 +11413,33 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
           const filtered = applyFolderFilter(mergedItems);
           const stateDb2 = getStateDb2();
           const sliced = filtered.slice(0, limit);
-          const results = sliced.map((item, i) => ({
-            ...(i < detailN ? enrichResult : enrichResultLight)({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
+          const results2 = sliced.map((item) => ({
+            ...enrichResultCompact({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
             ..."in_fts5" in item ? { in_fts5: true } : { in_entity: true }
           }));
-          if (stateDb2 && results.length < limit) {
-            const existingPaths = new Set(results.map((r) => r.path));
-            const backfill = [];
-            for (const r of results.slice(0, 3)) {
-              const rPath = r.path;
-              if (!rPath) continue;
-              try {
-                const outlinks = getStoredNoteLinks(stateDb2, rPath);
-                for (const target of outlinks) {
-                  const entityRow = stateDb2.db.prepare(
-                    "SELECT path FROM entities WHERE name_lower = ?"
-                  ).get(target);
-                  if (entityRow?.path && !existingPaths.has(entityRow.path)) {
-                    existingPaths.add(entityRow.path);
-                    backfill.push({
-                      ...enrichResultLight({ path: entityRow.path, title: target }, index, stateDb2)
-                    });
-                  }
-                }
-              } catch {
-              }
-            }
-            results.push(...backfill.slice(0, limit - results.length));
-          }
+          const hopResults2 = multiHopBackfill(results2, index, stateDb2, { maxBackfill: limit });
+          const expansionTerms2 = extractExpansionTerms(results2, query, index);
+          const expansionResults2 = expandQuery(expansionTerms2, [...results2, ...hopResults2], index, stateDb2);
+          results2.push(...hopResults2, ...expansionResults2);
           return { content: [{ type: "text", text: JSON.stringify({
             method: "fts5",
             query,
             total_results: filtered.length,
-            results
+            results: results2
           }, null, 2) }] };
         }
         const stateDbFts = getStateDb2();
         const fts5Filtered = applyFolderFilter(fts5Results);
-        const enrichedFts5 = fts5Filtered.map((r, i) => ({ ...(i < detailN ? enrichResult : enrichResultLight)({ path: r.path, title: r.title, snippet: r.snippet }, index, stateDbFts), in_fts5: true }));
+        const results = fts5Filtered.map((r) => ({ ...enrichResultCompact({ path: r.path, title: r.title, snippet: r.snippet }, index, stateDbFts), in_fts5: true }));
+        const hopResults = multiHopBackfill(results, index, stateDbFts, { maxBackfill: limit });
+        const expansionTerms = extractExpansionTerms(results, query, index);
+        const expansionResults = expandQuery(expansionTerms, [...results, ...hopResults], index, stateDbFts);
+        results.push(...hopResults, ...expansionResults);
         return { content: [{ type: "text", text: JSON.stringify({
           method: "fts5",
           query,
-          total_results: enrichedFts5.length,
-          results: enrichedFts5
+          total_results: results.length,
+          results
         }, null, 2) }] };
       }
       return { content: [{ type: "text", text: JSON.stringify({ error: "Provide a query or metadata filters (where, has_tag, folder, etc.)" }, null, 2) }] };
@@ -12030,7 +12165,7 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
 }
 
 // src/tools/read/primitives.ts
-import { getEntityByName as getEntityByName3 } from "@velvetmonkey/vault-core";
+import { getEntityByName as getEntityByName4 } from "@velvetmonkey/vault-core";
 function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = () => ({}), getStateDb2 = () => null) {
   server2.registerTool(
     "get_note_structure",
@@ -12073,7 +12208,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
       const stateDb2 = getStateDb2();
       if (stateDb2 && note) {
         try {
-          const entity = getEntityByName3(stateDb2, note.title);
+          const entity = getEntityByName4(stateDb2, note.title);
           if (entity) {
             enriched.category = entity.category;
             enriched.hub_score = entity.hubScore;
@@ -19325,13 +19460,13 @@ function registerRecallTools(server2, getStateDb2, getVaultPath, getIndex) {
               description: e.content,
               score: Math.round(e.score * 10) / 10,
               breakdown: e.breakdown,
-              ...enrichEntityResult(e.id, stateDb2, index)
+              ...enrichEntityCompact(e.id, stateDb2, index)
             })),
             notes: notes.map((n) => ({
               path: n.id,
               snippet: n.content,
               score: Math.round(n.score * 10) / 10,
-              ...enrichNoteResult(n.id, stateDb2, index)
+              ...enrichNoteCompact(n.id, stateDb2, index)
             })),
             memories: memories.map((m) => ({
               key: m.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.122",
+  "version": "2.0.124",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. Select from 69 tools for search, backlinks, graph queries, mutations, agent memory, and hybrid semantic search.",
   "type": "module",
   "main": "dist/index.js",