@velvetmonkey/flywheel-memory 2.0.49 → 2.0.50

package/dist/index.js

@@ -7381,7 +7381,7 @@ function refreshIfStale(vaultPath2, index, excludeTags) {
 }
 
 // src/index.ts
-import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, getAllEntitiesFromDb as getAllEntitiesFromDb3, findEntityMatches as findEntityMatches2, getProtectedZones as getProtectedZones2, rangeOverlapsProtectedZone } from "@velvetmonkey/vault-core";
+import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, getAllEntitiesFromDb as getAllEntitiesFromDb3, findEntityMatches as findEntityMatches2, getProtectedZones as getProtectedZones2, rangeOverlapsProtectedZone, detectImplicitEntities as detectImplicitEntities3 } from "@velvetmonkey/vault-core";
 
 // src/tools/read/graph.ts
 import * as fs9 from "fs";
@@ -7909,6 +7909,7 @@ function registerGraphTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/wikilinks.ts
 import { z as z2 } from "zod";
+import { detectImplicitEntities as detectImplicitEntities2 } from "@velvetmonkey/vault-core";
 function findEntityMatches(text, entities) {
   const matches = [];
   const sortedEntities = Array.from(entities.entries()).filter(([name]) => name.length >= 2).sort((a, b) => b[0].length - a[0].length);
@@ -8014,28 +8015,83 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
         text: z2.string().describe("The text to analyze for potential wikilinks"),
         limit: z2.coerce.number().default(50).describe("Maximum number of suggestions to return"),
         offset: z2.coerce.number().default(0).describe("Number of suggestions to skip (for pagination)"),
-        detail: z2.boolean().default(false).describe("Include per-layer score breakdown for each suggestion"),
-        note_path: z2.string().optional().describe("Path of the note being analyzed (enables strictness override for daily notes)")
+        detail: z2.boolean().default(false).describe("Include per-layer score breakdown for each suggestion")
       },
       outputSchema: SuggestWikilinksOutputSchema
     },
-    async ({ text, limit: requestedLimit, offset, detail, note_path }) => {
+    async ({ text, limit: requestedLimit, offset, detail }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
       const allMatches = findEntityMatches(text, index.entities);
       const matches = allMatches.slice(offset, offset + limit);
+      const linkedSet = new Set(allMatches.map((m) => m.entity.toLowerCase()));
+      const prospects = [];
+      const prospectSeen = /* @__PURE__ */ new Set();
+      for (const [target, links] of index.backlinks) {
+        if (links.length < 2) continue;
+        if (index.entities.has(target.toLowerCase())) continue;
+        if (linkedSet.has(target.toLowerCase())) continue;
+        const targetLower = target.toLowerCase();
+        const textLower = text.toLowerCase();
+        let searchPos = 0;
+        while (searchPos < textLower.length) {
+          const pos = textLower.indexOf(targetLower, searchPos);
+          if (pos === -1) break;
+          const end = pos + target.length;
+          const before = pos > 0 ? text[pos - 1] : " ";
+          const after = end < text.length ? text[end] : " ";
+          if (/[\s\n\r.,;:!?()[\]{}'"<>-]/.test(before) && /[\s\n\r.,;:!?()[\]{}'"<>-]/.test(after)) {
+            if (!prospectSeen.has(targetLower)) {
+              prospectSeen.add(targetLower);
+              prospects.push({
+                entity: text.substring(pos, end),
+                start: pos,
+                end,
+                source: "dead_link",
+                confidence: links.length >= 3 ? "high" : "medium",
+                backlink_count: links.length
+              });
+            }
+            break;
+          }
+          searchPos = pos + 1;
+        }
+      }
+      const implicit = detectImplicitEntities2(text);
+      for (const imp of implicit) {
+        const impLower = imp.text.toLowerCase();
+        if (linkedSet.has(impLower)) continue;
+        if (prospectSeen.has(impLower)) {
+          const existing = prospects.find((p) => p.entity.toLowerCase() === impLower);
+          if (existing) {
+            existing.source = "both";
+            existing.confidence = "high";
+          }
+          continue;
+        }
+        prospectSeen.add(impLower);
+        prospects.push({
+          entity: imp.text,
+          start: imp.start,
+          end: imp.end,
+          source: "implicit",
+          confidence: "low"
+        });
+      }
       const output = {
         input_length: text.length,
         suggestion_count: allMatches.length,
         returned_count: matches.length,
         suggestions: matches
       };
+      if (prospects.length > 0) {
+        output.prospects = prospects;
+      }
       if (detail) {
         const scored = await suggestRelatedLinks(text, {
           detail: true,
           maxSuggestions: limit,
-          strictness: "balanced",
-          ...note_path ? { notePath: note_path } : {}
+          strictness: "balanced"
         });
         if (scored.detailed) {
           output.scored_suggestions = scored.detailed;
@@ -18625,14 +18681,22 @@ async function runPostIndexWork(index) {
             }
           }
         }
+        const newDeadLinks = [];
+        for (const diff of linkDiffs) {
+          const newDead = diff.added.filter((target) => !vaultIndex.entities.has(target.toLowerCase()));
+          if (newDead.length > 0) {
+            newDeadLinks.push({ file: diff.file, targets: newDead });
+          }
+        }
         tracker.end({
           total_resolved: totalResolved,
           total_dead: totalDead,
           links: forwardLinkResults,
           link_diffs: linkDiffs,
-          survived: survivedLinks
+          survived: survivedLinks,
+          new_dead_links: newDeadLinks
         });
-        serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead`);
+        serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead${newDeadLinks.length > 0 ? `, ${newDeadLinks.reduce((s, d) => s + d.targets.length, 0)} new dead` : ""}`);
         tracker.start("wikilink_check", { files: filteredEvents.length });
         const trackedLinks = [];
         if (stateDb) {
@@ -18696,6 +18760,7 @@ async function runPostIndexWork(index) {
         tracker.end({ tracked: trackedLinks, mentions: mentionResults });
         serverLog("watcher", `Wikilink check: ${trackedLinks.reduce((s, t) => s + t.entities.length, 0)} tracked links in ${trackedLinks.length} files, ${mentionResults.reduce((s, m) => s + m.entities.length, 0)} unwikified mentions`);
         tracker.start("implicit_feedback", { files: filteredEvents.length });
+        const preSuppressed = stateDb ? new Set(getAllSuppressionPenalties(stateDb).keys()) : /* @__PURE__ */ new Set();
         const feedbackResults = [];
         if (stateDb) {
           for (const event of filteredEvents) {
@@ -18740,10 +18805,84 @@ async function runPostIndexWork(index) {
             }
           }
         }
-        tracker.end({ removals: feedbackResults, additions: additionResults });
+        const newlySuppressed = [];
+        if (stateDb) {
+          const postSuppressed = getAllSuppressionPenalties(stateDb);
+          for (const entity of postSuppressed.keys()) {
+            if (!preSuppressed.has(entity)) {
+              newlySuppressed.push(entity);
+            }
+          }
+        }
+        tracker.end({ removals: feedbackResults, additions: additionResults, newly_suppressed: newlySuppressed });
         if (feedbackResults.length > 0 || additionResults.length > 0) {
           serverLog("watcher", `Implicit feedback: ${feedbackResults.length} removals, ${additionResults.length} manual additions detected`);
         }
+        if (newlySuppressed.length > 0) {
+          serverLog("watcher", `Suppression: ${newlySuppressed.length} entities newly suppressed: ${newlySuppressed.join(", ")}`);
+        }
+        tracker.start("prospect_scan", { files: filteredEvents.length });
+        const prospectResults = [];
+        for (const event of filteredEvents) {
+          if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+          try {
+            const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const zones = getProtectedZones2(content);
+            const linkedSet = new Set(
+              (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).concat(forwardLinkResults.find((r) => r.file === event.path)?.dead ?? []).map((n) => n.toLowerCase())
+            );
+            const knownEntitySet = new Set(entitiesAfter.map((e) => e.nameLower));
+            const implicitMatches = detectImplicitEntities3(content);
+            const implicitNames = implicitMatches.filter((imp) => !linkedSet.has(imp.text.toLowerCase()) && !knownEntitySet.has(imp.text.toLowerCase())).map((imp) => imp.text);
+            const deadLinkMatches = [];
+            for (const [key, links] of vaultIndex.backlinks) {
+              if (links.length < 2 || vaultIndex.entities.has(key) || linkedSet.has(key)) continue;
+              const matches = findEntityMatches2(content, key, true);
+              if (matches.some((m) => !rangeOverlapsProtectedZone(m.start, m.end, zones))) {
+                deadLinkMatches.push(key);
+              }
+            }
+            if (implicitNames.length > 0 || deadLinkMatches.length > 0) {
+              prospectResults.push({ file: event.path, implicit: implicitNames, deadLinkMatches });
+            }
+          } catch {
+          }
+        }
+        tracker.end({ prospects: prospectResults });
+        if (prospectResults.length > 0) {
+          const implicitCount = prospectResults.reduce((s, p) => s + p.implicit.length, 0);
+          const deadCount = prospectResults.reduce((s, p) => s + p.deadLinkMatches.length, 0);
+          serverLog("watcher", `Prospect scan: ${implicitCount} implicit entities, ${deadCount} dead link matches across ${prospectResults.length} files`);
+        }
+        tracker.start("suggestion_scoring", { files: filteredEvents.length });
+        const suggestionResults = [];
+        for (const event of filteredEvents) {
+          if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+          try {
+            const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const result = await suggestRelatedLinks(content, {
+              maxSuggestions: 5,
+              strictness: "balanced",
+              notePath: event.path,
+              detail: true
+            });
+            if (result.detailed && result.detailed.length > 0) {
+              suggestionResults.push({
+                file: event.path,
+                top: result.detailed.slice(0, 5).map((s) => ({
+                  entity: s.entity,
+                  score: s.totalScore,
+                  confidence: s.confidence
+                }))
+              });
+            }
+          } catch {
+          }
+        }
+        tracker.end({ scored_files: suggestionResults.length, suggestions: suggestionResults });
+        if (suggestionResults.length > 0) {
+          serverLog("watcher", `Suggestion scoring: ${suggestionResults.length} files scored`);
+        }
         tracker.start("tag_scan", { files: filteredEvents.length });
         const tagDiffs = [];
         if (stateDb) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.49",
+  "version": "2.0.50",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. Select from 42 tools for search, backlinks, graph queries, mutations, and hybrid semantic search.",
   "type": "module",
   "main": "dist/index.js",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.49",
+    "@velvetmonkey/vault-core": "^2.0.50",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",