@velvetmonkey/flywheel-memory 2.0.40 → 2.0.41

package/dist/index.js

@@ -3721,13 +3721,25 @@ function getStoredNoteLinks(stateDb2, notePath) {
   return new Set(rows.map((r) => r.target));
 }
 function updateStoredNoteLinks(stateDb2, notePath, currentLinks) {
-  const del = stateDb2.db.prepare("DELETE FROM note_links WHERE note_path = ?");
-  const ins = stateDb2.db.prepare("INSERT INTO note_links (note_path, target) VALUES (?, ?)");
+  const ins = stateDb2.db.prepare(
+    "INSERT OR IGNORE INTO note_links (note_path, target) VALUES (?, ?)"
+  );
+  const del = stateDb2.db.prepare(
+    "DELETE FROM note_links WHERE note_path = ? AND target = ?"
+  );
+  const existing = stateDb2.db.prepare(
+    "SELECT target FROM note_links WHERE note_path = ?"
+  );
   const tx = stateDb2.db.transaction(() => {
-    del.run(notePath);
     for (const target of currentLinks) {
       ins.run(notePath, target);
     }
+    const rows = existing.all(notePath);
+    for (const row of rows) {
+      if (!currentLinks.has(row.target)) {
+        del.run(notePath, row.target);
+      }
+    }
   });
   tx();
 }
@@ -7315,7 +7327,7 @@ var GetBacklinksOutputSchema = {
   returned_count: z.coerce.number().describe("Number of backlinks returned (may be limited)"),
   backlinks: z.array(BacklinkItemSchema).describe("List of backlinks")
 };
-function registerGraphTools(server2, getIndex, getVaultPath) {
+function registerGraphTools(server2, getIndex, getVaultPath, getStateDb) {
   server2.registerTool(
     "get_backlinks",
     {
@@ -7437,6 +7449,89 @@ function registerGraphTools(server2, getIndex, getVaultPath) {
       };
     }
   );
+  server2.tool(
+    "get_weighted_links",
+    "Get outgoing links from a note ranked by edge weight. Weights reflect link survival, co-session access, and source activity. Time decay is applied at query time.",
+    {
+      path: z.string().describe('Path to the note (e.g., "daily/2026-02-24.md")'),
+      min_weight: z.number().default(0).describe("Minimum weight threshold (default 0 = all links)"),
+      limit: z.number().default(20).describe("Maximum number of results to return")
+    },
+    async ({ path: notePath, min_weight, limit: requestedLimit }) => {
+      const stateDb2 = getStateDb?.();
+      if (!stateDb2) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "StateDb not initialized" }) }] };
+      }
+      const limit = Math.min(requestedLimit ?? 20, MAX_LIMIT);
+      const now = Date.now();
+      const rows = stateDb2.db.prepare(`
+        SELECT target, weight, weight_updated_at
+        FROM note_links
+        WHERE note_path = ?
+        ORDER BY weight DESC
+      `).all(notePath);
+      const results = rows.map((row) => {
+        const daysSinceUpdated = row.weight_updated_at ? (now - row.weight_updated_at) / (1e3 * 60 * 60 * 24) : 0;
+        const decayFactor = Math.max(0.1, 1 - daysSinceUpdated / 180);
+        const effectiveWeight = Math.round(row.weight * decayFactor * 1e3) / 1e3;
+        return {
+          target: row.target,
+          weight: row.weight,
+          weight_effective: effectiveWeight,
+          last_updated: row.weight_updated_at
+        };
+      }).filter((r) => r.weight_effective >= min_weight).slice(0, limit);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            note: notePath,
+            count: results.length,
+            links: results
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "get_strong_connections",
+    "Get bidirectional connections for a note ranked by combined edge weight. Returns both outgoing and incoming links.",
+    {
+      path: z.string().describe('Path to the note (e.g., "daily/2026-02-24.md")'),
+      limit: z.number().default(20).describe("Maximum number of results to return")
+    },
+    async ({ path: notePath, limit: requestedLimit }) => {
+      const stateDb2 = getStateDb?.();
+      if (!stateDb2) {
+        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 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 = ?
+        ORDER BY weight DESC
+        LIMIT ?
+      `).all(notePath, stem2, limit);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            note: notePath,
+            count: rows.length,
+            connections: rows.map((r) => ({
+              node: r.node,
+              weight: r.weight,
+              direction: r.direction
+            }))
+          }, null, 2)
+        }]
+      };
+    }
+  );
 }
 
 // src/tools/read/wikilinks.ts
@@ -8827,9 +8922,11 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
       // Entity options (used with scope "entities")
       prefix: z4.boolean().default(false).describe("Enable prefix matching for entity search (autocomplete)"),
       // Pagination
-      limit: z4.number().default(20).describe("Maximum number of results to return")
+      limit: z4.number().default(20).describe("Maximum number of results to return"),
+      // Context boost (edge weights)
+      context_note: z4.string().optional().describe("Path of the note providing context. When set, results connected to this note via weighted edges get an RRF boost.")
     },
-    async ({ query, scope, where, has_tag, has_any_tag, has_all_tags, include_children, folder, title_contains, modified_after, modified_before, sort_by, order, prefix, limit: requestedLimit }) => {
+    async ({ query, scope, where, has_tag, has_any_tag, has_all_tags, include_children, folder, title_contains, modified_after, modified_before, sort_by, order, prefix, limit: requestedLimit, context_note }) => {
       const limit = Math.min(requestedLimit ?? 20, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
@@ -8940,17 +9037,47 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
             }
           }
         }
+        let edgeRanked = [];
+        if (context_note) {
+          const ctxStateDb = getStateDb();
+          if (ctxStateDb) {
+            try {
+              const edgeRows = ctxStateDb.db.prepare(`
+                SELECT nl.target, nl.weight FROM note_links nl
+                WHERE nl.note_path = ? AND nl.weight > 1.0
+                ORDER BY nl.weight DESC LIMIT ?
+              `).all(context_note, limit);
+              if (edgeRows.length > 0) {
+                const entityRows = ctxStateDb.db.prepare(
+                  "SELECT path, name_lower FROM entities"
+                ).all();
+                const targetToPath = /* @__PURE__ */ new Map();
+                for (const e of entityRows) {
+                  targetToPath.set(e.name_lower, e.path);
+                }
+                edgeRanked = edgeRows.map((r) => {
+                  const entityPath = targetToPath.get(r.target);
+                  return entityPath ? { path: entityPath, title: r.target } : null;
+                }).filter((r) => r !== null);
+              }
+            } catch {
+            }
+          }
+        }
         if (hasEmbeddingsIndex()) {
           try {
             const semanticResults = await semanticSearch(query, limit);
             const fts5Ranked = fts5Results.map((r) => ({ path: r.path, title: r.title, snippet: r.snippet }));
             const semanticRanked = semanticResults.map((r) => ({ path: r.path, title: r.title }));
-            const entityRanked = entityResults.map((r) => ({ path: r.path, title: r.name }));
-            const rrfScores = reciprocalRankFusion(fts5Ranked, semanticRanked, entityRanked);
+            const entityRankedList = entityResults.map((r) => ({ path: r.path, title: r.name }));
+            const rrfLists = [fts5Ranked, semanticRanked, entityRankedList];
+            if (edgeRanked.length > 0) rrfLists.push(edgeRanked);
+            const rrfScores = reciprocalRankFusion(...rrfLists);
             const allPaths = /* @__PURE__ */ new Set([
               ...fts5Results.map((r) => r.path),
               ...semanticResults.map((r) => r.path),
-              ...entityResults.map((r) => r.path)
+              ...entityResults.map((r) => r.path),
+              ...edgeRanked.map((r) => r.path)
             ]);
             const fts5Map = new Map(fts5Results.map((r) => [r.path, r]));
             const semanticMap = new Map(semanticResults.map((r) => [r.path, r]));
@@ -9075,6 +9202,123 @@ function suggestEntityAliases(stateDb2, folder) {
   return suggestions;
 }
 
+// src/core/write/edgeWeights.ts
+var moduleStateDb5 = null;
+function setEdgeWeightStateDb(stateDb2) {
+  moduleStateDb5 = stateDb2;
+}
+function buildPathToTargetsMap(stateDb2) {
+  const map = /* @__PURE__ */ new Map();
+  const rows = stateDb2.db.prepare(
+    "SELECT path, name_lower, aliases_json FROM entities"
+  ).all();
+  for (const row of rows) {
+    const targets = /* @__PURE__ */ new Set();
+    targets.add(row.name_lower);
+    if (row.aliases_json) {
+      try {
+        const aliases = JSON.parse(row.aliases_json);
+        for (const alias of aliases) {
+          targets.add(alias.toLowerCase());
+        }
+      } catch {
+      }
+    }
+    map.set(row.path, targets);
+  }
+  return map;
+}
+function pathToFallbackTarget(filePath) {
+  return filePath.replace(/\.md$/, "").split("/").pop()?.toLowerCase() ?? filePath.toLowerCase();
+}
+function recomputeEdgeWeights(stateDb2) {
+  const start = Date.now();
+  const edges = stateDb2.db.prepare(
+    "SELECT note_path, target FROM note_links"
+  ).all();
+  if (edges.length === 0) {
+    return { edges_updated: 0, duration_ms: Date.now() - start };
+  }
+  const survivalMap = /* @__PURE__ */ new Map();
+  const historyRows = stateDb2.db.prepare(
+    "SELECT note_path, target, edits_survived FROM note_link_history"
+  ).all();
+  for (const row of historyRows) {
+    survivalMap.set(`${row.note_path}\0${row.target}`, row.edits_survived);
+  }
+  const pathToTargets = buildPathToTargetsMap(stateDb2);
+  const targetToPaths = /* @__PURE__ */ new Map();
+  for (const [entityPath, targets] of pathToTargets) {
+    for (const target of targets) {
+      let paths = targetToPaths.get(target);
+      if (!paths) {
+        paths = /* @__PURE__ */ new Set();
+        targetToPaths.set(target, paths);
+      }
+      paths.add(entityPath);
+    }
+  }
+  const sessionRows = stateDb2.db.prepare(
+    `SELECT session_id, note_paths FROM tool_invocations
+     WHERE note_paths IS NOT NULL AND note_paths != '[]'`
+  ).all();
+  const sessionPaths = /* @__PURE__ */ new Map();
+  for (const row of sessionRows) {
+    try {
+      const paths = JSON.parse(row.note_paths);
+      if (!Array.isArray(paths) || paths.length === 0) continue;
+      let existing = sessionPaths.get(row.session_id);
+      if (!existing) {
+        existing = /* @__PURE__ */ new Set();
+        sessionPaths.set(row.session_id, existing);
+      }
+      for (const p of paths) {
+        existing.add(p);
+      }
+    } catch {
+    }
+  }
+  const coSessionCount = /* @__PURE__ */ new Map();
+  const sourceActivityCount = /* @__PURE__ */ new Map();
+  for (const [, paths] of sessionPaths) {
+    const sessionTargets = /* @__PURE__ */ new Set();
+    for (const p of paths) {
+      const targets = pathToTargets.get(p);
+      if (targets) {
+        for (const t of targets) sessionTargets.add(t);
+      } else {
+        sessionTargets.add(pathToFallbackTarget(p));
+      }
+    }
+    for (const edge of edges) {
+      if (paths.has(edge.note_path)) {
+        const srcKey = edge.note_path;
+        sourceActivityCount.set(srcKey, (sourceActivityCount.get(srcKey) ?? 0) + 1);
+        if (sessionTargets.has(edge.target)) {
+          const edgeKey = `${edge.note_path}\0${edge.target}`;
+          coSessionCount.set(edgeKey, (coSessionCount.get(edgeKey) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  const now = Date.now();
+  const update = stateDb2.db.prepare(
+    "UPDATE note_links SET weight = ?, weight_updated_at = ? WHERE note_path = ? AND target = ?"
+  );
+  const tx = stateDb2.db.transaction(() => {
+    for (const edge of edges) {
+      const edgeKey = `${edge.note_path}\0${edge.target}`;
+      const editsSurvived = survivalMap.get(edgeKey) ?? 0;
+      const coSessions = coSessionCount.get(edgeKey) ?? 0;
+      const sourceAccess = sourceActivityCount.get(edge.note_path) ?? 0;
+      const weight = 1 + editsSurvived * 0.5 + Math.min(coSessions * 0.5, 3) + Math.min(sourceAccess * 0.2, 2);
+      update.run(Math.round(weight * 1e3) / 1e3, now, edge.note_path, edge.target);
+    }
+  });
+  tx();
+  return { edges_updated: edges.length, duration_ms: Date.now() - start };
+}
+
 // src/tools/read/system.ts
 function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfig, getStateDb) {
   const RefreshIndexOutputSchema = {
@@ -9082,6 +9326,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
     notes_count: z5.number().describe("Number of notes indexed"),
     entities_count: z5.number().describe("Number of entities (titles + aliases)"),
     fts5_notes: z5.number().describe("Number of notes in FTS5 search index"),
+    edges_recomputed: z5.number().optional().describe("Number of edges with recomputed weights"),
     duration_ms: z5.number().describe("Time taken to rebuild index")
   };
   server2.registerTool(
@@ -9149,6 +9394,16 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
         } catch (err) {
           console.error("[Flywheel] FTS5 rebuild failed:", err);
         }
+        let edgesRecomputed = 0;
+        if (stateDb2) {
+          try {
+            const edgeResult = recomputeEdgeWeights(stateDb2);
+            edgesRecomputed = edgeResult.edges_updated;
+            console.error(`[Flywheel] Edge weights: ${edgeResult.edges_updated} edges in ${edgeResult.duration_ms}ms`);
+          } catch (err) {
+            console.error("[Flywheel] Edge weight recompute failed:", err);
+          }
+        }
         const duration = Date.now() - startTime;
         if (stateDb2) {
           recordIndexEvent(stateDb2, {
@@ -9162,6 +9417,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           notes_count: newIndex.notes.size,
           entities_count: newIndex.entities.size,
           fts5_notes: fts5Notes,
+          edges_recomputed: edgesRecomputed,
           duration_ms: duration
         };
         return {
@@ -16953,7 +17209,7 @@ registerSystemTools(
   },
   () => stateDb
 );
-registerGraphTools(server, () => vaultIndex, () => vaultPath);
+registerGraphTools(server, () => vaultIndex, () => vaultPath, () => stateDb);
 registerWikilinkTools(server, () => vaultIndex, () => vaultPath);
 registerQueryTools(server, () => vaultIndex, () => vaultPath, () => stateDb);
 registerPrimitiveTools(server, () => vaultIndex, () => vaultPath, () => flywheelConfig);
@@ -17007,6 +17263,7 @@ async function main() {
     loadEntityEmbeddingsToMemory();
     setWriteStateDb(stateDb);
     setRecencyStateDb(stateDb);
+    setEdgeWeightStateDb(stateDb);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     serverLog("statedb", `StateDb initialization failed: ${msg}`, "error");
@@ -17104,6 +17361,7 @@ async function main() {
 }
 var DEFAULT_ENTITY_EXCLUDE_FOLDERS = ["node_modules", "templates", "attachments", "tmp"];
 var lastCooccurrenceRebuildAt = 0;
+var lastEdgeWeightRebuildAt = 0;
 async function updateEntitiesInStateDb() {
   if (!stateDb) return;
   try {
@@ -17462,6 +17720,24 @@ async function runPostIndexWork(index) {
           tracker.end({ error: String(e) });
           serverLog("watcher", `Co-occurrence: failed: ${e}`);
         }
+        if (stateDb) {
+          tracker.start("edge_weights", {});
+          try {
+            const edgeWeightAgeMs = lastEdgeWeightRebuildAt > 0 ? Date.now() - lastEdgeWeightRebuildAt : Infinity;
+            if (edgeWeightAgeMs >= 60 * 60 * 1e3) {
+              const result = recomputeEdgeWeights(stateDb);
+              lastEdgeWeightRebuildAt = Date.now();
+              tracker.end({ rebuilt: true, edges: result.edges_updated, duration_ms: result.duration_ms });
+              serverLog("watcher", `Edge weights: ${result.edges_updated} edges in ${result.duration_ms}ms`);
+            } else {
+              tracker.end({ rebuilt: false, age_ms: edgeWeightAgeMs });
+              serverLog("watcher", `Edge weights: cache valid (${Math.round(edgeWeightAgeMs / 1e3)}s old)`);
+            }
+          } catch (e) {
+            tracker.end({ error: String(e) });
+            serverLog("watcher", `Edge weights: failed: ${e}`);
+          }
+        }
         if (hasEmbeddingsIndex()) {
           tracker.start("note_embeddings", { files: filteredEvents.length });
           let embUpdated = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.40",
+  "version": "2.0.41",
   "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",