@velvetmonkey/flywheel-memory 2.0.11 → 2.0.13

package/dist/index.js

@@ -2731,6 +2731,15 @@ import {
 // src/core/write/wikilinkFeedback.ts
 var MIN_FEEDBACK_COUNT = 10;
 var SUPPRESSION_THRESHOLD = 0.3;
+var FEEDBACK_BOOST_MIN_SAMPLES = 5;
+var FOLDER_SUPPRESSION_MIN_COUNT = 5;
+var FEEDBACK_BOOST_TIERS = [
+  { minAccuracy: 0.95, minSamples: 20, boost: 5 },
+  { minAccuracy: 0.8, minSamples: 5, boost: 2 },
+  { minAccuracy: 0.6, minSamples: 5, boost: 0 },
+  { minAccuracy: 0.4, minSamples: 5, boost: -2 },
+  { minAccuracy: 0, minSamples: 5, boost: -4 }
+];
 function recordFeedback(stateDb2, entity, context, notePath, correct) {
   stateDb2.db.prepare(
     "INSERT INTO wikilink_feedback (entity, context, note_path, correct) VALUES (?, ?, ?, ?)"
@@ -2814,11 +2823,31 @@ function updateSuppressionList(stateDb2) {
   transaction();
   return updated;
 }
-function isSuppressed(stateDb2, entity) {
+function isSuppressed(stateDb2, entity, folder) {
   const row = stateDb2.db.prepare(
     "SELECT entity FROM wikilink_suppressions WHERE entity = ?"
   ).get(entity);
-  return !!row;
+  if (row) return true;
+  if (folder !== void 0) {
+    const folderStats = stateDb2.db.prepare(`
+      SELECT
+        COUNT(*) as total,
+        SUM(CASE WHEN correct = 0 THEN 1 ELSE 0 END) as false_positives
+      FROM wikilink_feedback
+      WHERE entity = ? AND (
+        CASE WHEN ? = '' THEN note_path NOT LIKE '%/%'
+        ELSE note_path LIKE ? || '/%'
+        END
+      )
+    `).get(entity, folder, folder);
+    if (folderStats && folderStats.total >= FOLDER_SUPPRESSION_MIN_COUNT) {
+      const fpRate = folderStats.false_positives / folderStats.total;
+      if (fpRate >= SUPPRESSION_THRESHOLD) {
+        return true;
+      }
+    }
+  }
+  return false;
 }
 function getSuppressedCount(stateDb2) {
   const row = stateDb2.db.prepare(
@@ -2826,6 +2855,109 @@ function getSuppressedCount(stateDb2) {
   ).get();
   return row.count;
 }
+function computeBoostFromAccuracy(accuracy, sampleCount) {
+  if (sampleCount < FEEDBACK_BOOST_MIN_SAMPLES) return 0;
+  for (const tier of FEEDBACK_BOOST_TIERS) {
+    if (accuracy >= tier.minAccuracy && sampleCount >= tier.minSamples) {
+      return tier.boost;
+    }
+  }
+  return 0;
+}
+function getAllFeedbackBoosts(stateDb2, folder) {
+  const globalRows = stateDb2.db.prepare(`
+    SELECT
+      entity,
+      COUNT(*) as total,
+      SUM(CASE WHEN correct = 1 THEN 1 ELSE 0 END) as correct_count
+    FROM wikilink_feedback
+    GROUP BY entity
+    HAVING total >= ?
+  `).all(FEEDBACK_BOOST_MIN_SAMPLES);
+  let folderStats = null;
+  if (folder !== void 0) {
+    const folderRows = stateDb2.db.prepare(`
+      SELECT
+        entity,
+        COUNT(*) as total,
+        SUM(CASE WHEN correct = 1 THEN 1 ELSE 0 END) as correct_count
+      FROM wikilink_feedback
+      WHERE (
+        CASE WHEN ? = '' THEN note_path NOT LIKE '%/%'
+        ELSE note_path LIKE ? || '/%'
+        END
+      )
+      GROUP BY entity
+      HAVING total >= ?
+    `).all(folder, folder, FEEDBACK_BOOST_MIN_SAMPLES);
+    folderStats = /* @__PURE__ */ new Map();
+    for (const row of folderRows) {
+      folderStats.set(row.entity, {
+        accuracy: row.correct_count / row.total,
+        count: row.total
+      });
+    }
+  }
+  const boosts = /* @__PURE__ */ new Map();
+  for (const row of globalRows) {
+    let accuracy;
+    let sampleCount;
+    const fs25 = folderStats?.get(row.entity);
+    if (fs25 && fs25.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs25.accuracy;
+      sampleCount = fs25.count;
+    } else {
+      accuracy = row.correct_count / row.total;
+      sampleCount = row.total;
+    }
+    const boost = computeBoostFromAccuracy(accuracy, sampleCount);
+    if (boost !== 0) {
+      boosts.set(row.entity, boost);
+    }
+  }
+  return boosts;
+}
+function trackWikilinkApplications(stateDb2, notePath, entities) {
+  const upsert = stateDb2.db.prepare(`
+    INSERT INTO wikilink_applications (entity, note_path, applied_at, status)
+    VALUES (?, ?, datetime('now'), 'applied')
+    ON CONFLICT(entity, note_path) DO UPDATE SET
+      applied_at = datetime('now'),
+      status = 'applied'
+  `);
+  const transaction = stateDb2.db.transaction(() => {
+    for (const entity of entities) {
+      upsert.run(entity.toLowerCase(), notePath);
+    }
+  });
+  transaction();
+}
+function getTrackedApplications(stateDb2, notePath) {
+  const rows = stateDb2.db.prepare(
+    `SELECT entity FROM wikilink_applications WHERE note_path = ? AND status = 'applied'`
+  ).all(notePath);
+  return rows.map((r) => r.entity);
+}
+function processImplicitFeedback(stateDb2, notePath, currentContent) {
+  const tracked = getTrackedApplications(stateDb2, notePath);
+  if (tracked.length === 0) return [];
+  const currentLinks = extractLinkedEntities(currentContent);
+  const removed = [];
+  const markRemoved = stateDb2.db.prepare(
+    `UPDATE wikilink_applications SET status = 'removed' WHERE entity = ? AND note_path = ?`
+  );
+  const transaction = stateDb2.db.transaction(() => {
+    for (const entity of tracked) {
+      if (!currentLinks.has(entity)) {
+        recordFeedback(stateDb2, entity, "implicit:removed", notePath, false);
+        markRemoved.run(entity, notePath);
+        removed.push(entity);
+      }
+    }
+  });
+  transaction();
+  return removed;
+}
 
 // src/core/write/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
@@ -4174,6 +4306,9 @@ function setWriteStateDb(stateDb2) {
   setHintsStateDb(stateDb2);
   setRecencyStateDb(stateDb2);
 }
+function getWriteStateDb() {
+  return moduleStateDb4;
+}
 var entityIndex = null;
 var indexReady = false;
 var indexError2 = null;
@@ -4320,9 +4455,10 @@ function processWikilinks(content, notePath) {
   let entities = getAllEntities(entityIndex);
   console.error(`[Flywheel:DEBUG] Processing wikilinks with ${entities.length} entities`);
   if (moduleStateDb4) {
+    const folder = notePath ? notePath.split("/")[0] : void 0;
     entities = entities.filter((e) => {
       const name = getEntityName2(e);
-      return !isSuppressed(moduleStateDb4, name);
+      return !isSuppressed(moduleStateDb4, name, folder);
     });
   }
   const sortedEntities = sortEntitiesByPriority(entities, notePath);
@@ -4346,6 +4482,9 @@ function maybeApplyWikilinks(content, skipWikilinks, notePath) {
   checkAndRefreshIfStale();
   const result = processWikilinks(content, notePath);
   if (result.linksAdded > 0) {
+    if (moduleStateDb4 && notePath) {
+      trackWikilinkApplications(moduleStateDb4, notePath, result.linkedEntities);
+    }
     return {
       content: result.content,
       wikilinkInfo: `Applied ${result.linksAdded} wikilink(s): ${result.linkedEntities.join(", ")}`
@@ -4663,7 +4802,8 @@ function suggestRelatedLinks(content, options = {}) {
     maxSuggestions = 3,
     excludeLinked = true,
     strictness = DEFAULT_STRICTNESS,
-    notePath
+    notePath,
+    detail = false
   } = options;
   const config = STRICTNESS_CONFIGS[strictness];
   const adaptiveMinScore = getAdaptiveMinScore(content.length, config.minSuggestionScore);
@@ -4697,6 +4837,8 @@ function suggestRelatedLinks(content, options = {}) {
     return emptyResult;
   }
   const linkedEntities = excludeLinked ? extractLinkedEntities(content) : /* @__PURE__ */ new Set();
+  const noteFolder = notePath ? notePath.split("/")[0] : void 0;
+  const feedbackBoosts = moduleStateDb4 ? getAllFeedbackBoosts(moduleStateDb4, noteFolder) : /* @__PURE__ */ new Map();
   const scoredEntities = [];
   const directlyMatchedEntities = /* @__PURE__ */ new Set();
   const entitiesWithContentMatch = /* @__PURE__ */ new Set();
@@ -4717,20 +4859,38 @@ function suggestRelatedLinks(content, options = {}) {
     if (contentScore > 0) {
       entitiesWithContentMatch.add(entityName);
     }
-    score += TYPE_BOOST[category] || 0;
-    score += contextBoosts[category] || 0;
-    if (recencyIndex) {
-      score += getRecencyBoost(entityName, recencyIndex);
-    }
-    if (notePath && entity.path) {
-      score += getCrossFolderBoost(entity.path, notePath);
-    }
-    score += getHubBoost(entity);
+    const layerTypeBoost = TYPE_BOOST[category] || 0;
+    score += layerTypeBoost;
+    const layerContextBoost = contextBoosts[category] || 0;
+    score += layerContextBoost;
+    const layerRecencyBoost = recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
+    score += layerRecencyBoost;
+    const layerCrossFolderBoost = notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
+    score += layerCrossFolderBoost;
+    const layerHubBoost = getHubBoost(entity);
+    score += layerHubBoost;
+    const layerFeedbackAdj = feedbackBoosts.get(entityName) ?? 0;
+    score += layerFeedbackAdj;
     if (score > 0) {
       directlyMatchedEntities.add(entityName);
     }
     if (score >= adaptiveMinScore) {
-      scoredEntities.push({ name: entityName, score, category });
+      scoredEntities.push({
+        name: entityName,
+        path: entity.path || "",
+        score,
+        category,
+        breakdown: {
+          contentMatch: contentScore,
+          cooccurrenceBoost: 0,
+          typeBoost: layerTypeBoost,
+          contextBoost: layerContextBoost,
+          recencyBoost: layerRecencyBoost,
+          crossFolderBoost: layerCrossFolderBoost,
+          hubBoost: layerHubBoost,
+          feedbackAdjustment: layerFeedbackAdj
+        }
+      });
     }
   }
   if (cooccurrenceIndex && directlyMatchedEntities.size > 0) {
@@ -4745,6 +4905,7 @@ function suggestRelatedLinks(content, options = {}) {
         const existing = scoredEntities.find((e) => e.name === entityName);
         if (existing) {
           existing.score += boost;
+          existing.breakdown.cooccurrenceBoost += boost;
         } else {
           const entityTokens = tokenize(entityName);
           const hasContentOverlap = entityTokens.some(
@@ -4759,9 +4920,25 @@ function suggestRelatedLinks(content, options = {}) {
           const recencyBoostVal = recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
           const crossFolderBoost = notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
           const hubBoost = getHubBoost(entity);
-          const totalBoost = boost + typeBoost + contextBoost + recencyBoostVal + crossFolderBoost + hubBoost;
+          const feedbackAdj = feedbackBoosts.get(entityName) ?? 0;
+          const totalBoost = boost + typeBoost + contextBoost + recencyBoostVal + crossFolderBoost + hubBoost + feedbackAdj;
           if (totalBoost >= adaptiveMinScore) {
-            scoredEntities.push({ name: entityName, score: totalBoost, category });
+            scoredEntities.push({
+              name: entityName,
+              path: entity.path || "",
+              score: totalBoost,
+              category,
+              breakdown: {
+                contentMatch: 0,
+                cooccurrenceBoost: boost,
+                typeBoost,
+                contextBoost,
+                recencyBoost: recencyBoostVal,
+                crossFolderBoost,
+                hubBoost,
+                feedbackAdjustment: feedbackAdj
+              }
+            });
           }
         }
       }
@@ -4782,15 +4959,34 @@ function suggestRelatedLinks(content, options = {}) {
     }
     return 0;
   });
-  const topSuggestions = relevantEntities.slice(0, maxSuggestions).map((e) => e.name);
+  const topEntries = relevantEntities.slice(0, maxSuggestions);
+  const topSuggestions = topEntries.map((e) => e.name);
   if (topSuggestions.length === 0) {
     return emptyResult;
   }
   const suffix = "\u2192 " + topSuggestions.map((name) => `[[${name}]]`).join(", ");
-  return {
+  const result = {
     suggestions: topSuggestions,
     suffix
   };
+  if (detail) {
+    const feedbackStats = moduleStateDb4 ? getEntityStats(moduleStateDb4) : [];
+    const feedbackMap = new Map(feedbackStats.map((s) => [s.entity, s]));
+    result.detailed = topEntries.map((e) => {
+      const fb = feedbackMap.get(e.name);
+      const confidence = e.score >= 20 ? "high" : e.score >= 12 ? "medium" : "low";
+      return {
+        entity: e.name,
+        path: e.path,
+        totalScore: e.score,
+        breakdown: e.breakdown,
+        confidence,
+        feedbackCount: fb?.total ?? 0,
+        accuracy: fb ? fb.accuracy : void 0
+      };
+    });
+  }
+  return result;
 }
 function detectAliasCollisions(noteName, aliases = []) {
   if (!moduleStateDb4) return [];
@@ -5616,11 +5812,12 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
       inputSchema: {
         text: z2.string().describe("The text to analyze for potential wikilinks"),
         limit: z2.coerce.number().default(50).describe("Maximum number of suggestions to return"),
-        offset: z2.coerce.number().default(0).describe("Number of suggestions to skip (for pagination)")
+        offset: z2.coerce.number().default(0).describe("Number of suggestions to skip (for pagination)"),
+        detail: z2.boolean().default(false).describe("Include per-layer score breakdown for each suggestion")
       },
       outputSchema: SuggestWikilinksOutputSchema
     },
-    async ({ text, limit: requestedLimit, offset }) => {
+    async ({ text, limit: requestedLimit, offset, detail }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
       const allMatches = findEntityMatches(text, index.entities);
@@ -5631,6 +5828,16 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
         returned_count: matches.length,
         suggestions: matches
       };
+      if (detail) {
+        const scored = suggestRelatedLinks(text, {
+          detail: true,
+          maxSuggestions: limit,
+          strictness: "balanced"
+        });
+        if (scored.detailed) {
+          output.scored_suggestions = scored.detailed;
+        }
+      }
       return {
         content: [
           {
@@ -9103,6 +9310,10 @@ async function withVaultFile(options, operation) {
       return formatMcpResult(existsError);
     }
     const { content, frontmatter, lineEnding } = await readVaultFile(vaultPath2, notePath);
+    const writeStateDb = getWriteStateDb();
+    if (writeStateDb) {
+      processImplicitFeedback(writeStateDb, notePath, content);
+    }
     let sectionBoundary;
     if (section) {
       const sectionResult = ensureSectionExists(content, section, notePath);
@@ -12013,9 +12224,12 @@ var ALL_METRICS = [
   "entity_count",
   "avg_links_per_note",
   "link_density",
-  "connected_ratio"
+  "connected_ratio",
+  "wikilink_accuracy",
+  "wikilink_feedback_volume",
+  "wikilink_suppressed_count"
 ];
-function computeMetrics(index) {
+function computeMetrics(index, stateDb2) {
   const noteCount = index.notes.size;
   let linkCount = 0;
   for (const note of index.notes.values()) {
@@ -12050,6 +12264,18 @@ function computeMetrics(index) {
   const possibleLinks = noteCount * (noteCount - 1);
   const linkDensity = possibleLinks > 0 ? linkCount / possibleLinks : 0;
   const connectedRatio = noteCount > 0 ? connectedNotes.size / noteCount : 0;
+  let wikilinkAccuracy = 0;
+  let wikilinkFeedbackVolume = 0;
+  let wikilinkSuppressedCount = 0;
+  if (stateDb2) {
+    const entityStatsList = getEntityStats(stateDb2);
+    wikilinkFeedbackVolume = entityStatsList.reduce((sum, s) => sum + s.total, 0);
+    if (wikilinkFeedbackVolume > 0) {
+      const totalCorrect = entityStatsList.reduce((sum, s) => sum + s.correct, 0);
+      wikilinkAccuracy = Math.round(totalCorrect / wikilinkFeedbackVolume * 1e3) / 1e3;
+    }
+    wikilinkSuppressedCount = getSuppressedCount(stateDb2);
+  }
   return {
     note_count: noteCount,
     link_count: linkCount,
@@ -12058,7 +12284,10 @@ function computeMetrics(index) {
     entity_count: entityCount,
     avg_links_per_note: Math.round(avgLinksPerNote * 100) / 100,
     link_density: Math.round(linkDensity * 1e4) / 1e4,
-    connected_ratio: Math.round(connectedRatio * 1e3) / 1e3
+    connected_ratio: Math.round(connectedRatio * 1e3) / 1e3,
+    wikilink_accuracy: wikilinkAccuracy,
+    wikilink_feedback_volume: wikilinkFeedbackVolume,
+    wikilink_suppressed_count: wikilinkSuppressedCount
   };
 }
 function recordMetrics(stateDb2, metrics) {
@@ -12148,7 +12377,7 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
     "vault_growth",
     {
       title: "Vault Growth",
-      description: 'Track vault growth over time. Modes: "current" (live snapshot), "history" (time series), "trends" (deltas vs N days ago). Tracks 8 metrics: note_count, link_count, orphan_count, tag_count, entity_count, avg_links_per_note, link_density, connected_ratio.',
+      description: 'Track vault growth over time. Modes: "current" (live snapshot), "history" (time series), "trends" (deltas vs N days ago). Tracks 11 metrics: note_count, link_count, orphan_count, tag_count, entity_count, avg_links_per_note, link_density, connected_ratio, wikilink_accuracy, wikilink_feedback_volume, wikilink_suppressed_count.',
       inputSchema: {
         mode: z21.enum(["current", "history", "trends"]).describe("Query mode: current snapshot, historical time series, or trend analysis"),
         metric: z21.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
@@ -12162,7 +12391,7 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
       let result;
       switch (mode) {
         case "current": {
-          const metrics = computeMetrics(index);
+          const metrics = computeMetrics(index, stateDb2 ?? void 0);
           result = {
             mode: "current",
             metrics,
@@ -12189,7 +12418,7 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
               content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available for trend analysis" }) }]
             };
           }
-          const currentMetrics = computeMetrics(index);
+          const currentMetrics = computeMetrics(index, stateDb2);
           const trends = computeTrends(stateDb2, currentMetrics, daysBack);
           result = {
             mode: "trends",
@@ -12618,7 +12847,7 @@ async function runPostIndexWork(index) {
   await exportHubScores(index, stateDb);
   if (stateDb) {
     try {
-      const metrics = computeMetrics(index);
+      const metrics = computeMetrics(index, stateDb);
       recordMetrics(stateDb, metrics);
       purgeOldMetrics(stateDb, 90);
       console.error("[Memory] Growth metrics recorded");

package/package.json

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