@velvetmonkey/flywheel-memory 2.0.134 → 2.0.136

package/dist/index.js

@@ -3303,8 +3303,10 @@ __export(wikilinks_exports, {
   initializeEntityIndex: () => initializeEntityIndex,
   isEntityIndexReady: () => isEntityIndexReady,
   isLikelyArticleTitle: () => isLikelyArticleTitle,
+  isValidWikilinkText: () => isValidWikilinkText,
   maybeApplyWikilinks: () => maybeApplyWikilinks,
   processWikilinks: () => processWikilinks,
+  sanitizeWikilinks: () => sanitizeWikilinks,
   setCooccurrenceIndex: () => setCooccurrenceIndex,
   setWikilinkConfig: () => setWikilinkConfig,
   setWriteStateDb: () => setWriteStateDb,
@@ -3473,6 +3475,35 @@ function sortEntitiesByPriority(entities, notePath) {
     return priorityB - priorityA;
   });
 }
+function isValidWikilinkText(text) {
+  const target = text.includes("|") ? text.split("|")[0] : text;
+  if (target !== target.trim()) return false;
+  const trimmed = target.trim();
+  if (trimmed.length === 0) return false;
+  if (/[?!;]/.test(trimmed)) return false;
+  if (/[,.]$/.test(trimmed)) return false;
+  if (trimmed.includes(">")) return false;
+  if (/^[*#\-]/.test(trimmed)) return false;
+  if (trimmed.length > 60) return false;
+  const words = trimmed.split(/\s+/);
+  if (words.length > 5) return false;
+  if (words.length > 3 && trimmed === trimmed.toLowerCase()) return false;
+  if (words.length > 2 && /\w'\w/.test(trimmed)) return false;
+  if (words.length > 3 && /(?:ing|tion|ment|ness|ould|ould|ight)$/i.test(words[words.length - 1])) return false;
+  return true;
+}
+function sanitizeWikilinks(content) {
+  const removed = [];
+  const sanitized = content.replace(/\[\[([^\]]+?)\]\]/g, (fullMatch, inner) => {
+    if (isValidWikilinkText(inner)) {
+      return fullMatch;
+    }
+    removed.push(inner);
+    const display = inner.includes("|") ? inner.split("|")[1] : inner;
+    return display;
+  });
+  return { content: sanitized, removed };
+}
 function processWikilinks(content, notePath, existingContent) {
   if (!isEntityIndexReady() || !entityIndex) {
     return {
@@ -3514,8 +3545,9 @@ function processWikilinks(content, notePath, existingContent) {
     caseInsensitive: true,
     alreadyLinked: step1LinkedEntities
   });
+  const wordCount = content.split(/\s+/).length;
   const cfg = getConfig();
-  const implicitEnabled = cfg?.implicit_detection !== false;
+  const implicitEnabled = cfg?.implicit_detection !== false && wordCount <= 500;
   const validPatterns = new Set(ALL_IMPLICIT_PATTERNS);
   const implicitPatterns = cfg?.implicit_patterns?.length ? cfg.implicit_patterns.filter((p) => validPatterns.has(p)) : [...ALL_IMPLICIT_PATTERNS];
   const implicitMatches = detectImplicitEntities(result.content, {
@@ -3551,23 +3583,22 @@ function processWikilinks(content, notePath, existingContent) {
     }
   }
   newImplicits = nonOverlapping;
+  let finalContent = result.content;
+  let implicitEntities;
   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);
+      finalContent = finalContent.slice(0, m.start) + `[[${m.text}]]` + finalContent.slice(m.end);
     }
-    return {
-      content: processedContent,
-      linksAdded: resolved.linksAdded + result.linksAdded + newImplicits.length,
-      linkedEntities: [...resolved.linkedEntities, ...result.linkedEntities],
-      implicitEntities: newImplicits.map((m) => m.text)
-    };
+    implicitEntities = newImplicits.map((m) => m.text);
   }
+  const { content: sanitizedContent, removed } = sanitizeWikilinks(finalContent);
+  const totalLinksAdded = resolved.linksAdded + result.linksAdded + (newImplicits.length - removed.length);
   return {
-    content: result.content,
-    linksAdded: resolved.linksAdded + result.linksAdded,
-    linkedEntities: [...resolved.linkedEntities, ...result.linkedEntities]
+    content: sanitizedContent,
+    linksAdded: Math.max(0, totalLinksAdded),
+    linkedEntities: [...resolved.linkedEntities, ...result.linkedEntities],
+    ...implicitEntities ? { implicitEntities } : {}
   };
 }
 function maybeApplyWikilinks(content, skipWikilinks, notePath, existingContent) {
@@ -4545,6 +4576,125 @@ var init_wikilinks = __esm({
   }
 });
 
+// src/core/write/proactiveQueue.ts
+var proactiveQueue_exports = {};
+__export(proactiveQueue_exports, {
+  drainProactiveQueue: () => drainProactiveQueue,
+  enqueueProactiveSuggestions: () => enqueueProactiveSuggestions,
+  expireStaleEntries: () => expireStaleEntries
+});
+function enqueueProactiveSuggestions(stateDb2, entries) {
+  if (entries.length === 0) return 0;
+  const now = Date.now();
+  const expiresAt = now + QUEUE_TTL_MS;
+  const upsert = stateDb2.db.prepare(`
+    INSERT INTO proactive_queue (note_path, entity, score, confidence, queued_at, expires_at, status)
+    VALUES (?, ?, ?, ?, ?, ?, 'pending')
+    ON CONFLICT(note_path, entity) DO UPDATE SET
+      score = CASE WHEN excluded.score > proactive_queue.score THEN excluded.score ELSE proactive_queue.score END,
+      confidence = excluded.confidence,
+      queued_at = excluded.queued_at,
+      expires_at = excluded.expires_at,
+      status = 'pending'
+    WHERE proactive_queue.status = 'pending'
+  `);
+  let enqueued = 0;
+  for (const entry of entries) {
+    try {
+      const result = upsert.run(entry.notePath, entry.entity, entry.score, entry.confidence, now, expiresAt);
+      if (result.changes > 0) enqueued++;
+    } catch {
+    }
+  }
+  return enqueued;
+}
+async function drainProactiveQueue(stateDb2, vaultPath2, currentBatchPaths, config, applyFn) {
+  const result = {
+    applied: [],
+    expired: 0,
+    skippedActiveEdit: 0,
+    skippedMtimeGuard: 0,
+    skippedDailyCap: 0
+  };
+  result.expired = expireStaleEntries(stateDb2);
+  const now = Date.now();
+  const pending = stateDb2.db.prepare(`
+    SELECT note_path, entity, score, confidence
+    FROM proactive_queue
+    WHERE status = 'pending' AND expires_at > ?
+    ORDER BY note_path, score DESC
+  `).all(now);
+  if (pending.length === 0) return result;
+  const byFile = /* @__PURE__ */ new Map();
+  for (const row of pending) {
+    if (!byFile.has(row.note_path)) byFile.set(row.note_path, []);
+    byFile.get(row.note_path).push({ entity: row.entity, score: row.score, confidence: row.confidence });
+  }
+  const markApplied = stateDb2.db.prepare(
+    `UPDATE proactive_queue SET status = 'applied', applied_at = ? WHERE note_path = ? AND entity = ? AND status = 'pending'`
+  );
+  const todayMidnight = /* @__PURE__ */ new Date();
+  todayMidnight.setHours(0, 0, 0, 0);
+  const todayStr = todayMidnight.toISOString().slice(0, 10);
+  const countTodayApplied = stateDb2.db.prepare(
+    `SELECT COUNT(*) as cnt FROM wikilink_applications WHERE note_path = ? AND applied_at >= ?`
+  );
+  for (const [filePath, suggestions] of byFile) {
+    if (currentBatchPaths.has(filePath)) {
+      result.skippedActiveEdit += suggestions.length;
+      continue;
+    }
+    const todayCount = countTodayApplied.get(filePath, todayStr).cnt;
+    if (todayCount >= config.maxPerDay) {
+      result.skippedDailyCap += suggestions.length;
+      for (const s of suggestions) {
+        try {
+          stateDb2.db.prepare(
+            `UPDATE proactive_queue SET status = 'expired' WHERE note_path = ? AND entity = ? AND status = 'pending'`
+          ).run(filePath, s.entity);
+        } catch {
+        }
+      }
+      continue;
+    }
+    const remaining = config.maxPerDay - todayCount;
+    const capped = suggestions.slice(0, remaining);
+    try {
+      const applyResult = await applyFn(filePath, vaultPath2, capped, config);
+      if (applyResult.applied.length > 0) {
+        result.applied.push({ file: filePath, entities: applyResult.applied });
+        const appliedAt = Date.now();
+        for (const entity of applyResult.applied) {
+          try {
+            markApplied.run(appliedAt, filePath, entity);
+          } catch {
+          }
+        }
+      }
+      if (applyResult.applied.length === 0 && applyResult.skipped.length > 0) {
+        result.skippedMtimeGuard += applyResult.skipped.length;
+      }
+    } catch (e) {
+      serverLog("watcher", `Proactive drain: error applying to ${filePath}: ${e}`, "error");
+    }
+  }
+  return result;
+}
+function expireStaleEntries(stateDb2) {
+  const result = stateDb2.db.prepare(
+    `UPDATE proactive_queue SET status = 'expired' WHERE status = 'pending' AND expires_at <= ?`
+  ).run(Date.now());
+  return result.changes;
+}
+var QUEUE_TTL_MS;
+var init_proactiveQueue = __esm({
+  "src/core/write/proactiveQueue.ts"() {
+    "use strict";
+    init_serverLog();
+    QUEUE_TTL_MS = 60 * 60 * 1e3;
+  }
+});
+
 // src/core/write/constants.ts
 function estimateTokens(content) {
   const str = typeof content === "string" ? content : JSON.stringify(content);
@@ -7908,6 +8058,7 @@ async function exportHubScores(vaultIndex2, stateDb2) {
 init_recency();
 init_cooccurrence();
 init_wikilinks();
+init_proactiveQueue();
 init_retrievalCooccurrence();
 init_embeddings();
 
@@ -8305,6 +8456,7 @@ var PipelineRunner = class {
   async run() {
     const { p, tracker } = this;
     try {
+      await runStep("drain_proactive_queue", tracker, {}, () => this.drainQueue());
       await this.indexRebuild();
       this.noteMoves();
       await this.entityScan();
@@ -8929,33 +9081,61 @@ var PipelineRunner = class {
       serverLog("watcher", `Suggestion scoring: ${this.suggestionResults.length} files scored`);
     }
   }
-  // ── Step 12.5: Proactive linking ──────────────────────────────────
+  // ── Step 0.5: Drain proactive queue ──────────────────────────────
+  async drainQueue() {
+    const { p } = this;
+    if (!p.sd || p.flywheelConfig?.proactive_linking === false) {
+      return { skipped: true };
+    }
+    const currentBatchPaths = new Set(p.events.map((e) => e.path));
+    const result = await drainProactiveQueue(
+      p.sd,
+      p.vp,
+      currentBatchPaths,
+      {
+        minScore: p.flywheelConfig?.proactive_min_score ?? 20,
+        maxPerFile: p.flywheelConfig?.proactive_max_per_file ?? 3,
+        maxPerDay: p.flywheelConfig?.proactive_max_per_day ?? 10
+      },
+      applyProactiveSuggestions
+    );
+    const totalApplied = result.applied.reduce((s, r) => s + r.entities.length, 0);
+    if (totalApplied > 0) {
+      serverLog("watcher", `Proactive drain: applied ${totalApplied} links in ${result.applied.length} files`);
+    }
+    return {
+      applied: result.applied,
+      total_applied: totalApplied,
+      expired: result.expired,
+      skipped_active: result.skippedActiveEdit,
+      skipped_mtime: result.skippedMtimeGuard,
+      skipped_daily_cap: result.skippedDailyCap
+    };
+  }
+  // ── Step 12.5: Proactive enqueue ───────────────────────────────────
   async proactiveLinking() {
     const { p, tracker } = this;
     if (p.flywheelConfig?.proactive_linking === false || this.suggestionResults.length === 0) return;
-    tracker.start("proactive_linking", { files: this.suggestionResults.length });
+    if (!p.sd) return;
+    tracker.start("proactive_enqueue", { files: this.suggestionResults.length });
     try {
-      const proactiveResults = [];
+      const minScore = p.flywheelConfig?.proactive_min_score ?? 20;
+      const maxPerFile = p.flywheelConfig?.proactive_max_per_file ?? 3;
+      const entries = [];
       for (const { file, top } of this.suggestionResults) {
-        try {
-          const result = await applyProactiveSuggestions(file, p.vp, top, {
-            minScore: p.flywheelConfig?.proactive_min_score ?? 20,
-            maxPerFile: p.flywheelConfig?.proactive_max_per_file ?? 3
-          });
-          if (result.applied.length > 0) {
-            proactiveResults.push({ file, applied: result.applied });
-          }
-        } catch {
+        const candidates = top.filter((s) => s.score >= minScore && s.confidence === "high").slice(0, maxPerFile);
+        for (const c of candidates) {
+          entries.push({ notePath: file, entity: c.entity, score: c.score, confidence: c.confidence });
         }
       }
-      const totalApplied = proactiveResults.reduce((s, r) => s + r.applied.length, 0);
-      tracker.end({ files_modified: proactiveResults.length, total_applied: totalApplied, results: proactiveResults });
-      if (totalApplied > 0) {
-        serverLog("watcher", `Proactive linking: ${totalApplied} links in ${proactiveResults.length} files`);
+      const enqueued = enqueueProactiveSuggestions(p.sd, entries);
+      tracker.end({ enqueued, total_candidates: entries.length });
+      if (enqueued > 0) {
+        serverLog("watcher", `Proactive enqueue: ${enqueued} suggestions queued for deferred application`);
       }
     } catch (e) {
       tracker.end({ error: String(e) });
-      serverLog("watcher", `Proactive linking failed: ${e}`, "error");
+      serverLog("watcher", `Proactive enqueue failed: ${e}`, "error");
     }
   }
   // ── Step 13: Tag scan ─────────────────────────────────────────────
@@ -10081,6 +10261,45 @@ function buildGraphData(index, stateDb2, options) {
       }
     }
   }
+  if (options.center_entity) {
+    const centerLower = options.center_entity.toLowerCase();
+    const maxDepth = options.depth ?? 1;
+    const centerNode = nodes.find((n) => n.label.toLowerCase() === centerLower);
+    if (centerNode) {
+      const adj = /* @__PURE__ */ new Map();
+      for (const edge of edges) {
+        if (!adj.has(edge.source)) adj.set(edge.source, /* @__PURE__ */ new Set());
+        if (!adj.has(edge.target)) adj.set(edge.target, /* @__PURE__ */ new Set());
+        adj.get(edge.source).add(edge.target);
+        adj.get(edge.target).add(edge.source);
+      }
+      const reachable = /* @__PURE__ */ new Set();
+      const queue = [{ id: centerNode.id, depth: 0 }];
+      reachable.add(centerNode.id);
+      while (queue.length > 0) {
+        const { id, depth } = queue.shift();
+        if (depth >= maxDepth) continue;
+        for (const neighbor of adj.get(id) ?? []) {
+          if (!reachable.has(neighbor)) {
+            reachable.add(neighbor);
+            queue.push({ id: neighbor, depth: depth + 1 });
+          }
+        }
+      }
+      const filteredNodes = nodes.filter((n) => reachable.has(n.id));
+      const filteredEdges = edges.filter((e) => reachable.has(e.source) && reachable.has(e.target));
+      return {
+        nodes: filteredNodes,
+        edges: filteredEdges,
+        metadata: {
+          note_count: filteredNodes.filter((n) => n.type === "note").length,
+          entity_count: filteredNodes.filter((n) => n.type === "entity").length,
+          edge_count: filteredEdges.length,
+          exported_at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }
+  }
   return {
     nodes,
     edges,
@@ -10152,17 +10371,19 @@ function toGraphML(data) {
 function registerGraphExportTools(server2, getIndex, getVaultPath, getStateDb2) {
   server2.tool(
     "export_graph",
-    "Export the vault knowledge graph as GraphML (for Gephi/yEd/Cytoscape) or JSON. Includes notes, entities, wikilinks, edge weights, and co-occurrence relationships. Use the output with graph visualization tools to explore your vault structure.",
+    'Export the vault knowledge graph as GraphML (for Gephi/yEd/Cytoscape) or JSON. Includes notes, entities, wikilinks, edge weights, and co-occurrence relationships. Use center_entity + depth for focused ego-network exports (e.g., "everything within 2 hops of Acme Corp").',
     {
       format: z2.enum(["graphml", "json"]).default("graphml").describe('Output format: "graphml" for graph tools (Gephi, yEd, Cytoscape), "json" for programmatic use'),
       include_cooccurrence: z2.boolean().default(true).describe("Include co-occurrence edges between entities"),
-      min_edge_weight: z2.number().default(0).describe("Minimum edge weight threshold (filters weighted edges)")
+      min_edge_weight: z2.number().default(0).describe("Minimum edge weight threshold (filters weighted edges)"),
+      center_entity: z2.string().optional().describe("Center the export on this entity (ego network). Only includes nodes within `depth` hops."),
+      depth: z2.number().default(1).describe("Hops from center_entity to include (default 1). Ignored without center_entity.")
     },
-    async ({ format, include_cooccurrence, min_edge_weight }) => {
+    async ({ format, include_cooccurrence, min_edge_weight, center_entity, depth }) => {
       requireIndex();
       const index = getIndex();
       const stateDb2 = getStateDb2?.() ?? null;
-      const data = buildGraphData(index, stateDb2, { include_cooccurrence, min_edge_weight });
+      const data = buildGraphData(index, stateDb2, { include_cooccurrence, min_edge_weight, center_entity, depth });
       let output;
       if (format === "json") {
         output = JSON.stringify(data, null, 2);
@@ -24236,6 +24457,9 @@ async function runPostIndexWork(ctx) {
           const renameWikilinkApplications = sd.db.prepare(
             "UPDATE wikilink_applications SET note_path = ? WHERE note_path = ?"
           );
+          const renameProactiveQueue = sd.db.prepare(
+            "UPDATE proactive_queue SET note_path = ? WHERE note_path = ? AND status = 'pending'"
+          );
           for (const rename of batchRenames) {
             const oldFolder = rename.oldPath.includes("/") ? rename.oldPath.split("/").slice(0, -1).join("/") : "";
             const newFolder = rename.newPath.includes("/") ? rename.newPath.split("/").slice(0, -1).join("/") : "";
@@ -24244,6 +24468,7 @@ async function runPostIndexWork(ctx) {
             renameNoteTags.run(rename.newPath, rename.oldPath);
             renameNoteLinkHistory.run(rename.newPath, rename.oldPath);
             renameWikilinkApplications.run(rename.newPath, rename.oldPath);
+            renameProactiveQueue.run(rename.newPath, rename.oldPath);
             const oldHash = lastContentHashes.get(rename.oldPath);
             if (oldHash !== void 0) {
               lastContentHashes.set(rename.newPath, oldHash);
@@ -24313,6 +24538,16 @@ async function runPostIndexWork(ctx) {
         }
       }
     }
+    if (sd) {
+      try {
+        const { expireStaleEntries: expireStaleEntries2 } = await Promise.resolve().then(() => (init_proactiveQueue(), proactiveQueue_exports));
+        const expired = expireStaleEntries2(sd);
+        if (expired > 0) {
+          serverLog("watcher", `Startup: expired ${expired} stale proactive queue entries`);
+        }
+      } catch {
+      }
+    }
     watcher.start();
     serverLog("watcher", "File watcher started");
   }

package/package.json

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