@velvetmonkey/flywheel-memory 2.0.157 → 2.1.0

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;
@@ -665,8 +677,13 @@ function diagnoseEmbeddings(vaultPath2) {
     } else {
       checks.push({ name: "entity_orphans", status: "ok", detail: "0 orphaned" });
     }
-  } catch {
-    checks.push({ name: "entity_orphans", status: "ok", detail: "No entity embeddings table" });
+  } catch (e) {
+    const msg = String(e);
+    if (msg.includes("no such table")) {
+      checks.push({ name: "entity_orphans", status: "ok", detail: "No entity embeddings table" });
+    } else {
+      checks.push({ name: "entity_orphans", status: "warning", detail: "Could not check entity orphans" });
+    }
   }
   try {
     const samples = db4.prepare("SELECT embedding FROM note_embeddings ORDER BY RANDOM() LIMIT 3").all();
@@ -7701,6 +7718,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) {
@@ -7784,15 +7833,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++;
       }
     }
@@ -7807,9 +7857,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);
@@ -8752,7 +8807,12 @@ var PipelineRunner = class {
         } catch {
         }
       }
-      const orphansRemoved = removeOrphanedNoteEmbeddings();
+      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 {
@@ -8785,7 +8845,8 @@ var PipelineRunner = class {
         }
         const currentNames = new Set(allEntities.map((e) => e.name));
         entEmbOrphansRemoved = removeOrphanedEntityEmbeddings(currentNames);
-      } catch {
+      } catch (e) {
+        serverLog("watcher", `Entity embedding update/orphan cleanup failed: ${e}`, "error");
       }
       tracker.end({ updated: entEmbUpdated, updated_entities: entEmbNames.slice(0, 10), orphans_removed: entEmbOrphansRemoved });
       serverLog("watcher", `Entity embeddings: ${entEmbUpdated} updated, ${entEmbOrphansRemoved} orphans cleaned`);
@@ -9336,10 +9397,15 @@ var PipelineRunner = class {
       return { skipped: true, reason: "vacuumed recently" };
     }
     p.sd.db.pragma("incremental_vacuum");
-    p.sd.db.pragma("wal_checkpoint(TRUNCATE)");
-    p.sd.setMetadataValue.run("last_incremental_vacuum", String(Date.now()));
-    serverLog("watcher", "Incremental vacuum + WAL checkpoint completed");
-    return { vacuumed: true, wal_checkpointed: 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 };
   }
 };
 
@@ -9842,11 +9908,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;
@@ -10878,14 +10942,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 {
     }
   }
@@ -12757,16 +12825,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",
@@ -22974,6 +23044,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb3) {
       if (!force) {
         const diagnosis2 = diagnoseEmbeddings(vaultPath2);
         if (diagnosis2.healthy) {
+          setEmbeddingsBuildState("complete");
           return {
             content: [{
               type: "text",
@@ -24986,19 +25057,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 _earlyVaultConfigs = parseVaultConfig();
-var vaultPath = _earlyVaultConfigs ? _earlyVaultConfigs[0].path : process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
+var vaultPath;
 var resolvedVaultPath;
-try {
-  resolvedVaultPath = realpathSync(vaultPath).replace(/\\/g, "/");
-} catch {
-  resolvedVaultPath = vaultPath.replace(/\\/g, "/");
-}
-if (!existsSync3(resolvedVaultPath)) {
-  console.error(`[flywheel] Fatal: vault path does not exist: ${resolvedVaultPath}`);
-  console.error(`[flywheel] Set PROJECT_PATH or VAULT_PATH to a valid Obsidian vault directory.`);
-  process.exit(1);
-}
 var vaultIndex;
 var flywheelConfig = {};
 var stateDb = null;
@@ -25262,10 +25322,21 @@ async function bootVault(ctx, startTime) {
   }
 }
 async function main() {
+  const vaultConfigs = parseVaultConfig();
+  vaultPath = vaultConfigs ? vaultConfigs[0].path : process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
+  try {
+    resolvedVaultPath = realpathSync(vaultPath).replace(/\\/g, "/");
+  } catch {
+    resolvedVaultPath = vaultPath.replace(/\\/g, "/");
+  }
+  if (!existsSync3(resolvedVaultPath)) {
+    console.error(`[flywheel] Fatal: vault path does not exist: ${resolvedVaultPath}`);
+    console.error(`[flywheel] Set PROJECT_PATH or VAULT_PATH to a valid Obsidian vault directory.`);
+    process.exit(1);
+  }
   serverLog("server", `Starting Flywheel Memory v${pkg.version}...`);
   serverLog("server", `Vault: ${vaultPath}`);
   const startTime = Date.now();
-  const vaultConfigs = _earlyVaultConfigs;
   if (vaultConfigs) {
     vaultRegistry = new VaultRegistry(vaultConfigs[0].name);
     serverLog("server", `Multi-vault mode: ${vaultConfigs.map((v) => v.name).join(", ")}`);
@@ -25752,17 +25823,19 @@ async function runPostIndexWork(ctx) {
 }
 if (process.argv.includes("--init-semantic")) {
   (async () => {
+    const semanticVaultConfigs = parseVaultConfig();
+    const semanticVaultPath = semanticVaultConfigs ? semanticVaultConfigs[0].path : process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
     console.error("[Semantic] Pre-warming semantic search...");
-    console.error(`[Semantic] Vault: ${vaultPath}`);
+    console.error(`[Semantic] Vault: ${semanticVaultPath}`);
     try {
-      const db4 = openStateDb(vaultPath);
+      const db4 = openStateDb(semanticVaultPath);
       setEmbeddingsDatabase(db4.db);
       const storedModel = getStoredEmbeddingModel();
       if (storedModel && storedModel !== getActiveModelId()) {
         console.error(`[Semantic] Model changed ${storedModel} \u2192 ${getActiveModelId()}, clearing`);
         clearEmbeddingsForRebuild();
       }
-      const progress = await buildEmbeddingsIndex(vaultPath, (p) => {
+      const progress = await buildEmbeddingsIndex(semanticVaultPath, (p) => {
         if (p.current % 50 === 0 || p.current === p.total) {
           console.error(`[Semantic] Embedding ${p.current}/${p.total} notes (${p.skipped} skipped)...`);
         }
@@ -25782,6 +25855,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,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.157",
+  "version": "2.1.0",
   "description": "MCP tools that search, write, and auto-link your Obsidian vault — and learn from your edits.",
   "type": "module",
   "main": "dist/index.js",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.157",
+    "@velvetmonkey/vault-core": "^2.1.0",
     "better-sqlite3": "^12.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",