@velvetmonkey/flywheel-memory 2.0.32 → 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) {
@@ -3403,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;
@@ -5078,12 +5079,22 @@ function processWikilinks(content, notePath) {
     }
   }
   const currentNoteName = notePath ? notePath.replace(/\.md$/, "").split("/").pop()?.toLowerCase() : null;
-  const newImplicits = implicitMatches.filter((m) => {
+  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--) {
@@ -7414,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());
@@ -7426,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 };
@@ -7520,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(),
@@ -7529,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"),
@@ -7626,6 +7653,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         }
       }
       let lastPipeline;
+      let recentPipelines;
       if (stateDb2) {
         try {
           const evt = getRecentPipelineEvent(stateDb2);
@@ -7635,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 = {
@@ -7661,6 +7704,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         config: configInfo,
         last_rebuild: lastRebuild,
         last_pipeline: lastPipeline,
+        recent_pipelines: recentPipelines,
         fts5_ready: ftsState.ready,
         fts5_building: ftsState.building,
         embeddings_building: isEmbeddingsBuilding(),
@@ -15542,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(
@@ -16034,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`);
@@ -16177,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`);
+          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 });
@@ -16206,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) {
@@ -16219,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");
@@ -16258,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.32",
+  "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.32",
+    "@velvetmonkey/vault-core": "^2.0.33",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",