@velvetmonkey/flywheel-memory 2.0.156 → 2.0.158

package/dist/index.js

@@ -557,6 +557,18 @@ function hasEmbeddingsIndex() {
       const row = db4.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
       return row.count > 0;
     }
+    if (!isEmbeddingsBuilding()) {
+      const row = db4.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
+      if (row.count > 0) {
+        setEmbeddingsBuildState("complete");
+        console.error("[Semantic] Recovered stale embeddings_state \u2192 complete");
+        return true;
+      } else {
+        setEmbeddingsBuildState("none");
+        console.error("[Semantic] Recovered stale embeddings_state \u2192 none (no rows)");
+        return false;
+      }
+    }
     return false;
   } catch {
     return false;
@@ -575,7 +587,7 @@ function getStoredEmbeddingModel() {
 function diagnoseEmbeddings(vaultPath2) {
   const db4 = getDb();
   const checks = [];
-  const counts = { embedded: 0, vaultNotes: 0, orphaned: 0, missing: 0 };
+  const counts = { embedded: 0, vaultNotes: 0, orphaned: 0, orphanedEntities: 0, missing: 0 };
   if (!db4) {
     checks.push({ name: "database", status: "stale", detail: "No database available" });
     return { healthy: false, checks, counts };
@@ -649,6 +661,25 @@ function diagnoseEmbeddings(vaultPath2) {
   } catch {
     checks.push({ name: "orphans", status: "warning", detail: "Could not check" });
   }
+  try {
+    const embNames = new Set(
+      db4.prepare("SELECT entity_name FROM entity_embeddings").all().map((r) => r.entity_name)
+    );
+    const entityNames = new Set(
+      db4.prepare("SELECT name FROM entities").all().map((r) => r.name)
+    );
+    counts.orphanedEntities = 0;
+    for (const n of embNames) {
+      if (!entityNames.has(n)) counts.orphanedEntities++;
+    }
+    if (counts.orphanedEntities > 0) {
+      checks.push({ name: "entity_orphans", status: "warning", detail: `${counts.orphanedEntities} orphaned entity embeddings` });
+    } else {
+      checks.push({ name: "entity_orphans", status: "ok", detail: "0 orphaned" });
+    }
+  } catch {
+    checks.push({ name: "entity_orphans", status: "warning", detail: "Could not check entity embeddings" });
+  }
   try {
     const samples = db4.prepare("SELECT embedding FROM note_embeddings ORDER BY RANDOM() LIMIT 3").all();
     let corrupt = false;
@@ -732,6 +763,7 @@ async function buildEntityEmbeddingsIndex(vaultPath2, entities, onProgress) {
   const total = entities.size;
   let done = 0;
   let updated = 0;
+  let skipped = 0;
   for (const [name, entity] of entities) {
     done++;
     try {
@@ -745,7 +777,11 @@ async function buildEntityEmbeddingsIndex(vaultPath2, entities, onProgress) {
       const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
       upsert.run(name, buf, hash, activeModelConfig.id, Date.now());
       updated++;
-    } catch {
+    } catch (err) {
+      skipped++;
+      if (skipped <= 3) {
+        console.error(`[Semantic] Failed to embed entity ${name}: ${err instanceof Error ? err.message : err}`);
+      }
     }
     if (onProgress) onProgress(done, total);
   }
@@ -755,7 +791,7 @@ async function buildEntityEmbeddingsIndex(vaultPath2, entities, onProgress) {
       deleteStmt.run(existingName);
     }
   }
-  console.error(`[Semantic] Entity embeddings: ${updated} updated, ${total - updated} unchanged`);
+  console.error(`[Semantic] Entity embeddings: ${updated} updated, ${total - updated - skipped} unchanged, ${skipped} failed`);
   return updated;
 }
 async function updateEntityEmbedding(entityName, entity, vaultPath2) {
@@ -773,9 +809,34 @@ async function updateEntityEmbedding(entityName, entity, vaultPath2) {
       VALUES (?, ?, ?, ?, ?)
     `).run(entityName, buf, hash, activeModelConfig.id, Date.now());
     entityEmbeddingsMap.set(entityName, embedding);
-  } catch {
+  } catch (err) {
+    console.error(`[Semantic] Failed to update entity embedding ${entityName}: ${err instanceof Error ? err.message : err}`);
   }
 }
+function removeOrphanedNoteEmbeddings() {
+  const db4 = getDb();
+  if (!db4) return 0;
+  const result = db4.prepare(
+    "DELETE FROM note_embeddings WHERE path NOT IN (SELECT path FROM notes_fts)"
+  ).run();
+  return result.changes;
+}
+function removeOrphanedEntityEmbeddings(currentEntityNames) {
+  const db4 = getDb();
+  if (!db4) return 0;
+  const rows = db4.prepare("SELECT entity_name FROM entity_embeddings").all();
+  const deleteStmt = db4.prepare("DELETE FROM entity_embeddings WHERE entity_name = ?");
+  const embMap = getEmbMap();
+  let removed = 0;
+  for (const row of rows) {
+    if (!currentEntityNames.has(row.entity_name)) {
+      deleteStmt.run(row.entity_name);
+      embMap.delete(row.entity_name);
+      removed++;
+    }
+  }
+  return removed;
+}
 function findSemanticallySimilarEntities(queryEmbedding, limit, excludeEntities) {
   const scored = [];
   for (const [entityName, embedding] of getEmbMap()) {
@@ -7652,6 +7713,38 @@ function purgeOldNoteLinkHistory(stateDb2, retentionDays = 90) {
   return result.changes;
 }
 
+// src/core/read/identity.ts
+function normalizeResolvedPath(notePath) {
+  return notePath.toLowerCase().replace(/\.md$/, "");
+}
+function getInboundTargetsForNote(stateDb2, notePath) {
+  const targets = /* @__PURE__ */ new Set();
+  const stem2 = notePath.replace(/\.md$/, "").split("/").pop()?.toLowerCase();
+  const normalizedPath = normalizeResolvedPath(notePath);
+  if (stateDb2) {
+    try {
+      const row = stateDb2.db.prepare(
+        `SELECT name_lower, aliases_json FROM entities
+         WHERE LOWER(REPLACE(path, '.md', '')) = ?`
+      ).get(normalizedPath);
+      if (row) {
+        targets.add(row.name_lower);
+        if (row.aliases_json) {
+          try {
+            for (const alias of JSON.parse(row.aliases_json)) {
+              targets.add(alias.toLowerCase());
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (stem2) targets.add(stem2);
+  return [...targets];
+}
+
 // src/core/shared/hubExport.ts
 var EIGEN_ITERATIONS = 50;
 function computeHubScores(index) {
@@ -7735,15 +7828,16 @@ function computeHubScores(index) {
   }
   return { scores: result, edgeCount };
 }
-function updateHubScoresInDb(stateDb2, hubScores) {
-  const updateStmt = stateDb2.db.prepare(`
-    UPDATE entities SET hub_score = ? WHERE name_lower = ?
-  `);
+function updateHubScoresInDb(stateDb2, hubScores, pathToId) {
+  const resetAll = stateDb2.db.prepare("UPDATE entities SET hub_score = 0");
+  const updateById = stateDb2.db.prepare("UPDATE entities SET hub_score = ? WHERE id = ?");
   let updated = 0;
   const transaction = stateDb2.db.transaction(() => {
-    for (const [nameLower, score] of hubScores) {
-      const result = updateStmt.run(score, nameLower);
-      if (result.changes > 0) {
+    resetAll.run();
+    for (const [normalizedPath, score] of hubScores) {
+      const entityId = pathToId.get(normalizedPath);
+      if (entityId !== void 0) {
+        updateById.run(score, entityId);
         updated++;
       }
     }
@@ -7758,9 +7852,14 @@ async function exportHubScores(vaultIndex2, stateDb2) {
   }
   const { scores: hubScores, edgeCount } = computeHubScores(vaultIndex2);
   console.error(`[Flywheel] Computed hub scores for ${hubScores.size} notes (${edgeCount} edges in graph)`);
+  const entityRows = stateDb2.db.prepare("SELECT id, path FROM entities").all();
+  const pathToId = /* @__PURE__ */ new Map();
+  for (const row of entityRows) {
+    pathToId.set(normalizeResolvedPath(row.path), row.id);
+  }
   try {
-    const updated = updateHubScoresInDb(stateDb2, hubScores);
-    console.error(`[Flywheel] Updated ${updated} hub scores in StateDb`);
+    const updated = updateHubScoresInDb(stateDb2, hubScores, pathToId);
+    console.error(`[Flywheel] Hub scores: ${updated}/${hubScores.size} scores mapped to entities (all others reset to 0)`);
     return updated;
   } catch (e) {
     console.error("[Flywheel] Failed to update hub scores in StateDb:", e);
@@ -8703,8 +8802,14 @@ var PipelineRunner = class {
         } catch {
         }
       }
-      tracker.end({ updated: embUpdated, removed: embRemoved });
-      serverLog("watcher", `Note embeddings: ${embUpdated} updated, ${embRemoved} removed`);
+      let orphansRemoved = 0;
+      try {
+        orphansRemoved = removeOrphanedNoteEmbeddings();
+      } catch (e) {
+        serverLog("watcher", `Note embedding orphan cleanup failed: ${e}`, "error");
+      }
+      tracker.end({ updated: embUpdated, removed: embRemoved, orphans_removed: orphansRemoved });
+      serverLog("watcher", `Note embeddings: ${embUpdated} updated, ${embRemoved} removed, ${orphansRemoved} orphans cleaned`);
     } else {
       tracker.skip("note_embeddings", "not built");
     }
@@ -8715,6 +8820,7 @@ var PipelineRunner = class {
     if (hasEntityEmbeddingsIndex() && p.sd) {
       tracker.start("entity_embeddings", { files: p.events.length });
       let entEmbUpdated = 0;
+      let entEmbOrphansRemoved = 0;
       const entEmbNames = [];
       try {
         const allEntities = getAllEntitiesFromDb(p.sd);
@@ -8732,10 +8838,13 @@ var PipelineRunner = class {
             entEmbNames.push(entity.name);
           }
         }
-      } catch {
+        const currentNames = new Set(allEntities.map((e) => e.name));
+        entEmbOrphansRemoved = removeOrphanedEntityEmbeddings(currentNames);
+      } catch (e) {
+        serverLog("watcher", `Entity embedding update/orphan cleanup failed: ${e}`, "error");
       }
-      tracker.end({ updated: entEmbUpdated, updated_entities: entEmbNames.slice(0, 10) });
-      serverLog("watcher", `Entity embeddings: ${entEmbUpdated} updated`);
+      tracker.end({ updated: entEmbUpdated, updated_entities: entEmbNames.slice(0, 10), orphans_removed: entEmbOrphansRemoved });
+      serverLog("watcher", `Entity embeddings: ${entEmbUpdated} updated, ${entEmbOrphansRemoved} orphans cleaned`);
     } else {
       tracker.skip("entity_embeddings", !p.sd ? "no sd" : "not built");
     }
@@ -9283,9 +9392,15 @@ var PipelineRunner = class {
       return { skipped: true, reason: "vacuumed recently" };
     }
     p.sd.db.pragma("incremental_vacuum");
-    p.sd.setMetadataValue.run("last_incremental_vacuum", String(Date.now()));
-    serverLog("watcher", "Incremental vacuum completed");
-    return { vacuumed: true };
+    const walResult = p.sd.db.pragma("wal_checkpoint(TRUNCATE)");
+    const checkpointed = walResult?.[0]?.busy === 0;
+    if (checkpointed) {
+      p.sd.setMetadataValue.run("last_incremental_vacuum", String(Date.now()));
+      serverLog("watcher", "Incremental vacuum + WAL checkpoint completed");
+    } else {
+      serverLog("watcher", "Incremental vacuum done, WAL checkpoint skipped (busy readers)");
+    }
+    return { vacuumed: true, wal_checkpointed: checkpointed };
   }
 };
 
@@ -9788,11 +9903,9 @@ function computeMetrics(index, stateDb2) {
     for (const bl of backlinks) {
       connectedNotes.add(bl.source);
     }
-    for (const note of index.notes.values()) {
-      const normalizedTitle = note.title.toLowerCase();
-      if (normalizedTitle === target.toLowerCase() || note.path.toLowerCase() === target.toLowerCase()) {
-        connectedNotes.add(note.path);
-      }
+    const targetPath = index.entities.get(target);
+    if (targetPath && index.notes.has(targetPath)) {
+      connectedNotes.add(targetPath);
     }
   }
   let orphanCount = 0;
@@ -10824,14 +10937,18 @@ function rankOutlinks(outlinks, notePath, index, stateDb2, maxLinks = TOP_LINKS)
   }).sort((a, b) => (b.weight ?? 1) - (a.weight ?? 1)).slice(0, maxLinks);
 }
 function rankBacklinks(backlinks, notePath, index, stateDb2, maxLinks = TOP_LINKS) {
-  const stem2 = notePath.replace(/\.md$/, "").split("/").pop()?.toLowerCase() ?? "";
+  const targets = getInboundTargetsForNote(stateDb2, notePath);
   const weightMap = /* @__PURE__ */ new Map();
-  if (stateDb2 && stem2) {
+  if (stateDb2 && targets.length > 0) {
     try {
+      const placeholders = targets.map(() => "?").join(",");
       const rows = stateDb2.db.prepare(
-        "SELECT note_path, weight FROM note_links WHERE target = ?"
-      ).all(stem2);
-      for (const row of rows) weightMap.set(row.note_path, row.weight);
+        `SELECT note_path, weight FROM note_links WHERE target IN (${placeholders})`
+      ).all(...targets);
+      for (const row of rows) {
+        const existing = weightMap.get(row.note_path) ?? 0;
+        weightMap.set(row.note_path, Math.max(existing, row.weight));
+      }
     } catch {
     }
   }
@@ -12703,16 +12820,18 @@ function registerGraphTools(server2, getIndex, getVaultPath, getStateDb3) {
         return { content: [{ type: "text", text: JSON.stringify({ error: "StateDb not initialized" }) }] };
       }
       const limit = Math.min(requestedLimit ?? 20, MAX_LIMIT);
-      const stem2 = notePath.replace(/\.md$/, "").split("/").pop()?.toLowerCase() ?? "";
+      const targets = getInboundTargetsForNote(stateDb2, notePath);
+      const inPlaceholders = targets.map(() => "?").join(",");
       const rows = stateDb2.db.prepare(`
         SELECT target AS node, weight, 'outgoing' AS direction
         FROM note_links WHERE note_path = ?
         UNION ALL
-        SELECT note_path AS node, weight, 'incoming' AS direction
-        FROM note_links WHERE target = ?
+        SELECT note_path AS node, MAX(weight) AS weight, 'incoming' AS direction
+        FROM note_links WHERE target IN (${inPlaceholders})
+        GROUP BY note_path
         ORDER BY weight DESC
         LIMIT ?
-      `).all(notePath, stem2, limit);
+      `).all(notePath, ...targets, limit);
       return {
         content: [{
           type: "text",
@@ -22920,6 +23039,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb3) {
       if (!force) {
         const diagnosis2 = diagnoseEmbeddings(vaultPath2);
         if (diagnosis2.healthy) {
+          setEmbeddingsBuildState("complete");
           return {
             content: [{
               type: "text",
@@ -24932,7 +25052,8 @@ function registerAllTools(targetServer, ctx) {
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname7(__filename);
 var pkg = JSON.parse(readFileSync6(join21(__dirname, "../package.json"), "utf-8"));
-var vaultPath = process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
+var _earlyVaultConfigs = parseVaultConfig();
+var vaultPath = _earlyVaultConfigs ? _earlyVaultConfigs[0].path : process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
 var resolvedVaultPath;
 try {
   resolvedVaultPath = realpathSync(vaultPath).replace(/\\/g, "/");
@@ -25727,6 +25848,19 @@ if (process.argv.includes("--init-semantic")) {
     process.exit(1);
   });
 }
+function gracefulShutdown(signal) {
+  console.error(`[Memory] Received ${signal}, shutting down...`);
+  try {
+    watcherInstance?.stop();
+  } catch {
+  }
+  stopSweepTimer();
+  flushLogs().catch(() => {
+  }).finally(() => process.exit(0));
+  setTimeout(() => process.exit(0), 2e3).unref();
+}
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
 process.on("beforeExit", async () => {
   stopSweepTimer();
   await flushLogs();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.156",
-  "description": "MCP tools that search, write, and auto-link your Obsidian vault — and learn from your edits.",
+  "version": "2.0.158",
+  "description": "MCP tools that search, write, and auto-link your Obsidian vault \u2014 and learn from your edits.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -54,7 +54,7 @@
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.156",
+    "@velvetmonkey/vault-core": "^2.0.158",
     "better-sqlite3": "^12.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",