@velvetmonkey/flywheel-memory 2.0.31 → 2.0.33

package/dist/index.js

@@ -2486,7 +2486,8 @@ import {
 var DEFAULT_CONFIG = {
   exclude_task_tags: [],
   exclude_analysis_tags: [],
-  exclude_entities: []
+  exclude_entities: [],
+  exclude_entity_folders: []
 };
 function loadConfig(stateDb2) {
   if (stateDb2) {
@@ -3216,6 +3217,7 @@ import {
   getEntityAliases,
   applyWikilinks,
   resolveAliasWikilinks,
+  detectImplicitEntities,
   getEntityIndexFromDb,
   getStateDbMetadata,
   getEntityByName,
@@ -3402,10 +3404,10 @@ function getAllFeedbackBoosts(stateDb2, folder) {
   for (const row of globalRows) {
     let accuracy;
     let sampleCount;
-    const fs30 = folderStats?.get(row.entity);
-    if (fs30 && fs30.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
-      accuracy = fs30.accuracy;
-      sampleCount = fs30.count;
+    const fs31 = folderStats?.get(row.entity);
+    if (fs31 && fs31.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs31.accuracy;
+      sampleCount = fs31.count;
     } else {
       accuracy = row.correct_count / row.total;
       sampleCount = row.total;
@@ -5060,6 +5062,52 @@ function processWikilinks(content, notePath) {
     firstOccurrenceOnly: true,
     caseInsensitive: true
   });
+  const implicitMatches = detectImplicitEntities(result.content, {
+    detectImplicit: true,
+    implicitPatterns: ["proper-nouns", "single-caps", "quoted-terms", "camel-case", "acronyms"],
+    minEntityLength: 3
+  });
+  const alreadyLinked = new Set(
+    [...resolved.linkedEntities, ...result.linkedEntities].map((e) => e.toLowerCase())
+  );
+  for (const entity of sortedEntities) {
+    const name = getEntityName2(entity);
+    alreadyLinked.add(name.toLowerCase());
+    const aliases = getEntityAliases(entity);
+    for (const alias of aliases) {
+      alreadyLinked.add(alias.toLowerCase());
+    }
+  }
+  const currentNoteName = notePath ? notePath.replace(/\.md$/, "").split("/").pop()?.toLowerCase() : null;
+  let newImplicits = implicitMatches.filter((m) => {
+    const normalized = m.text.toLowerCase();
+    if (alreadyLinked.has(normalized)) return false;
+    if (currentNoteName && normalized === currentNoteName) return false;
+    return true;
+  });
+  const nonOverlapping = [];
+  for (const match of newImplicits) {
+    const overlaps = nonOverlapping.some(
+      (existing) => match.start >= existing.start && match.start < existing.end || match.end > existing.start && match.end <= existing.end || match.start <= existing.start && match.end >= existing.end
+    );
+    if (!overlaps) {
+      nonOverlapping.push(match);
+    }
+  }
+  newImplicits = nonOverlapping;
+  if (newImplicits.length > 0) {
+    let processedContent = result.content;
+    for (let i = newImplicits.length - 1; i >= 0; i--) {
+      const m = newImplicits[i];
+      processedContent = processedContent.slice(0, m.start) + `[[${m.text}]]` + processedContent.slice(m.end);
+    }
+    return {
+      content: processedContent,
+      linksAdded: resolved.linksAdded + result.linksAdded + newImplicits.length,
+      linkedEntities: [...resolved.linkedEntities, ...result.linkedEntities],
+      implicitEntities: newImplicits.map((m) => m.text)
+    };
+  }
   return {
     content: result.content,
     linksAdded: resolved.linksAdded + result.linksAdded,
@@ -5076,9 +5124,11 @@ function maybeApplyWikilinks(content, skipWikilinks, notePath) {
     if (moduleStateDb4 && notePath) {
       trackWikilinkApplications(moduleStateDb4, notePath, result.linkedEntities);
     }
+    const implicitCount = result.implicitEntities?.length ?? 0;
+    const implicitInfo = implicitCount > 0 ? ` + ${implicitCount} implicit: ${result.implicitEntities.join(", ")}` : "";
     return {
       content: result.content,
-      wikilinkInfo: `Applied ${result.linksAdded} wikilink(s): ${result.linkedEntities.join(", ")}`
+      wikilinkInfo: `Applied ${result.linksAdded} wikilink(s): ${result.linkedEntities.join(", ")}${implicitInfo}`
     };
   }
   return { content: result.content };
@@ -7375,7 +7425,7 @@ function computeEntityDiff(before, after) {
   const alias_changes = [];
   for (const [key, entity] of afterMap) {
     if (!beforeMap.has(key)) {
-      added.push(entity.name);
+      added.push({ name: entity.name, category: entity.category, path: entity.path });
     } else {
       const prev = beforeMap.get(key);
       const prevAliases = JSON.stringify(prev.aliases.sort());
@@ -7387,7 +7437,7 @@ function computeEntityDiff(before, after) {
   }
   for (const [key, entity] of beforeMap) {
     if (!afterMap.has(key)) {
-      removed.push(entity.name);
+      removed.push({ name: entity.name, category: entity.category, path: entity.path });
     }
   }
   return { added, removed, alias_changes };
@@ -7481,6 +7531,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       trigger: z3.string(),
       duration_ms: z3.number(),
       files_changed: z3.number().nullable(),
+      changed_paths: z3.array(z3.string()).nullable(),
       steps: z3.array(z3.object({
         name: z3.string(),
         duration_ms: z3.number(),
@@ -7490,6 +7541,21 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         skip_reason: z3.string().optional()
       }))
     }).optional().describe("Most recent watcher pipeline run with per-step timing"),
+    recent_pipelines: z3.array(z3.object({
+      timestamp: z3.number(),
+      trigger: z3.string(),
+      duration_ms: z3.number(),
+      files_changed: z3.number().nullable(),
+      changed_paths: z3.array(z3.string()).nullable(),
+      steps: z3.array(z3.object({
+        name: z3.string(),
+        duration_ms: z3.number(),
+        input: z3.record(z3.unknown()),
+        output: z3.record(z3.unknown()),
+        skipped: z3.boolean().optional(),
+        skip_reason: z3.string().optional()
+      }))
+    })).optional().describe("Up to 5 most recent pipeline runs with steps data"),
     fts5_ready: z3.boolean().describe("Whether the FTS5 keyword search index is ready"),
     fts5_building: z3.boolean().describe("Whether the FTS5 keyword search index is currently building"),
     embeddings_building: z3.boolean().describe("Whether semantic embeddings are currently building"),
@@ -7535,7 +7601,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         recommendations.push(`Index is ${Math.floor(indexAge / 60)} minutes old. Consider running refresh_index.`);
       }
       const noteCount = indexBuilt ? index.notes.size : 0;
-      const entityCount2 = indexBuilt ? index.entities.size : 0;
+      const entityCount = indexBuilt ? index.entities.size : 0;
       const tagCount = indexBuilt ? index.tags.size : 0;
       let linkCount = 0;
       if (indexBuilt) {
@@ -7587,6 +7653,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         }
       }
       let lastPipeline;
+      let recentPipelines;
       if (stateDb2) {
         try {
           const evt = getRecentPipelineEvent(stateDb2);
@@ -7596,11 +7663,26 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
               trigger: evt.trigger,
               duration_ms: evt.duration_ms,
               files_changed: evt.files_changed,
+              changed_paths: evt.changed_paths,
               steps: evt.steps
             };
           }
         } catch {
         }
+        try {
+          const events = getRecentIndexEvents(stateDb2, 10).filter((e) => e.steps && e.steps.length > 0).slice(0, 5);
+          if (events.length > 0) {
+            recentPipelines = events.map((e) => ({
+              timestamp: e.timestamp,
+              trigger: e.trigger,
+              duration_ms: e.duration_ms,
+              files_changed: e.files_changed,
+              changed_paths: e.changed_paths,
+              steps: e.steps
+            }));
+          }
+        } catch {
+        }
       }
       const ftsState = getFTS5State();
       const output = {
@@ -7615,13 +7697,14 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         index_age_seconds: indexAge,
         index_stale: indexStale,
         note_count: noteCount,
-        entity_count: entityCount2,
+        entity_count: entityCount,
         tag_count: tagCount,
         link_count: linkCount,
         periodic_notes: periodicNotes && periodicNotes.length > 0 ? periodicNotes : void 0,
         config: configInfo,
         last_rebuild: lastRebuild,
         last_pipeline: lastPipeline,
+        recent_pipelines: recentPipelines,
         fts5_ready: ftsState.ready,
         fts5_building: ftsState.building,
         embeddings_building: isEmbeddingsBuilding(),
@@ -14544,7 +14627,7 @@ function computeMetrics(index, stateDb2) {
     }
   }
   const tagCount = index.tags.size;
-  const entityCount2 = index.entities.size;
+  const entityCount = index.entities.size;
   const avgLinksPerNote = noteCount > 0 ? linkCount / noteCount : 0;
   const possibleLinks = noteCount * (noteCount - 1);
   const linkDensity = possibleLinks > 0 ? linkCount / possibleLinks : 0;
@@ -14566,7 +14649,7 @@ function computeMetrics(index, stateDb2) {
     link_count: linkCount,
     orphan_count: orphanCount,
     tag_count: tagCount,
-    entity_count: entityCount2,
+    entity_count: entityCount,
     avg_links_per_note: Math.round(avgLinksPerNote * 100) / 100,
     link_density: Math.round(linkDensity * 1e4) / 1e4,
     connected_ratio: Math.round(connectedRatio * 1e3) / 1e3,
@@ -15503,6 +15586,9 @@ function registerMergeTools2(server2, getStateDb) {
   );
 }
 
+// src/index.ts
+import * as fs30 from "node:fs/promises";
+
 // src/resources/vault.ts
 function registerVaultResources(server2, getIndex) {
   server2.registerResource(
@@ -15995,31 +16081,14 @@ async function main() {
     }
   }
 }
+var DEFAULT_ENTITY_EXCLUDE_FOLDERS = ["node_modules", "templates", "attachments", "tmp"];
 async function updateEntitiesInStateDb() {
   if (!stateDb) return;
   try {
+    const config = loadConfig(stateDb);
+    const excludeFolders = config.exclude_entity_folders?.length ? config.exclude_entity_folders : DEFAULT_ENTITY_EXCLUDE_FOLDERS;
     const entityIndex2 = await scanVaultEntities3(vaultPath, {
-      excludeFolders: [
-        "daily-notes",
-        "daily",
-        "weekly",
-        "weekly-notes",
-        "monthly",
-        "monthly-notes",
-        "quarterly",
-        "yearly-notes",
-        "periodic",
-        "journal",
-        "inbox",
-        "templates",
-        "attachments",
-        "tmp",
-        "clippings",
-        "readwise",
-        "articles",
-        "bookmarks",
-        "web-clips"
-      ]
+      excludeFolders
     });
     stateDb.replaceAllEntities(entityIndex2);
     serverLog("index", `Updated ${entityIndex2._metadata.total_entities} entities in StateDb`);
@@ -16138,9 +16207,22 @@ async function runPostIndexWork(index) {
           const entityDiff = computeEntityDiff(entitiesBefore, entitiesAfter);
           tracker.end({ entity_count: entitiesAfter.length, ...entityDiff });
           serverLog("watcher", `Entity scan: ${entitiesAfter.length} entities`);
-          tracker.start("hub_scores", { entity_count: entityCount });
+          const hubBefore = /* @__PURE__ */ new Map();
+          if (stateDb) {
+            const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
+            for (const r of rows) hubBefore.set(r.name, r.hub_score);
+          }
+          tracker.start("hub_scores", { entity_count: entitiesAfter.length });
           const hubUpdated = await exportHubScores(vaultIndex, stateDb);
-          tracker.end({ updated: hubUpdated ?? 0 });
+          const hubDiffs = [];
+          if (stateDb) {
+            const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
+            for (const r of rows) {
+              const prev = hubBefore.get(r.name) ?? 0;
+              if (prev !== r.hub_score) hubDiffs.push({ entity: r.name, before: prev, after: r.hub_score });
+            }
+          }
+          tracker.end({ updated: hubUpdated ?? 0, diffs: hubDiffs.slice(0, 10) });
           serverLog("watcher", `Hub scores: ${hubUpdated ?? 0} updated`);
           if (hasEmbeddingsIndex()) {
             tracker.start("note_embeddings", { files: batch.events.length });
@@ -16167,6 +16249,7 @@ async function runPostIndexWork(index) {
           if (hasEntityEmbeddingsIndex() && stateDb) {
             tracker.start("entity_embeddings", { files: batch.events.length });
             let entEmbUpdated = 0;
+            const entEmbNames = [];
             try {
               const allEntities = getAllEntitiesFromDb3(stateDb);
               for (const event of batch.events) {
@@ -16180,11 +16263,12 @@ async function runPostIndexWork(index) {
                     aliases: entity.aliases
                   }, vaultPath);
                   entEmbUpdated++;
+                  entEmbNames.push(entity.name);
                 }
               }
             } catch {
             }
-            tracker.end({ updated: entEmbUpdated });
+            tracker.end({ updated: entEmbUpdated, updated_entities: entEmbNames.slice(0, 10) });
             serverLog("watcher", `Entity embeddings: ${entEmbUpdated} updated`);
           } else {
             tracker.skip("entity_embeddings", !stateDb ? "no stateDb" : "not built");
@@ -16219,6 +16303,37 @@ async function runPostIndexWork(index) {
           }
           tracker.end({ updated: taskUpdated, removed: taskRemoved });
           serverLog("watcher", `Task cache: ${taskUpdated} updated, ${taskRemoved} removed`);
+          tracker.start("wikilink_check", { files: batch.events.length });
+          const trackedLinks = [];
+          if (stateDb) {
+            for (const event of batch.events) {
+              if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+              try {
+                const apps = getTrackedApplications(stateDb, event.path);
+                if (apps.length > 0) trackedLinks.push({ file: event.path, entities: apps });
+              } catch {
+              }
+            }
+          }
+          tracker.end({ tracked: trackedLinks });
+          serverLog("watcher", `Wikilink check: ${trackedLinks.reduce((s, t) => s + t.entities.length, 0)} tracked links in ${trackedLinks.length} files`);
+          tracker.start("implicit_feedback", { files: batch.events.length });
+          const feedbackResults = [];
+          if (stateDb) {
+            for (const event of batch.events) {
+              if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+              try {
+                const content = await fs30.readFile(path29.join(vaultPath, event.path), "utf-8");
+                const removed = processImplicitFeedback(stateDb, event.path, content);
+                for (const entity of removed) feedbackResults.push({ entity, file: event.path });
+              } catch {
+              }
+            }
+          }
+          tracker.end({ removals: feedbackResults });
+          if (feedbackResults.length > 0) {
+            serverLog("watcher", `Implicit feedback: ${feedbackResults.length} removals detected`);
+          }
           const duration = Date.now() - batchStart;
           if (stateDb) {
             recordIndexEvent(stateDb, {

package/package.json

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