@velvetmonkey/flywheel-memory 2.0.16 → 2.0.18

package/dist/index.js

@@ -1426,7 +1426,6 @@ var init_taskHelpers = __esm({
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import chokidar2 from "chokidar";
 
 // src/core/read/vault.ts
 import * as fs from "fs";
@@ -6187,9 +6186,84 @@ function getActivitySummary(index, days) {
   };
 }
 
+// src/core/shared/indexActivity.ts
+function recordIndexEvent(stateDb2, event) {
+  stateDb2.db.prepare(
+    `INSERT INTO index_events (timestamp, trigger, duration_ms, success, note_count, files_changed, changed_paths, error)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    Date.now(),
+    event.trigger,
+    event.duration_ms,
+    event.success !== false ? 1 : 0,
+    event.note_count ?? null,
+    event.files_changed ?? null,
+    event.changed_paths ? JSON.stringify(event.changed_paths) : null,
+    event.error ?? null
+  );
+}
+function rowToEvent(row) {
+  return {
+    id: row.id,
+    timestamp: row.timestamp,
+    trigger: row.trigger,
+    duration_ms: row.duration_ms,
+    success: row.success === 1,
+    note_count: row.note_count,
+    files_changed: row.files_changed,
+    changed_paths: row.changed_paths ? JSON.parse(row.changed_paths) : null,
+    error: row.error
+  };
+}
+function getRecentIndexEvents(stateDb2, limit = 20) {
+  const rows = stateDb2.db.prepare(
+    "SELECT * FROM index_events ORDER BY timestamp DESC LIMIT ?"
+  ).all(limit);
+  return rows.map(rowToEvent);
+}
+function getIndexActivitySummary(stateDb2) {
+  const now = Date.now();
+  const todayStart = /* @__PURE__ */ new Date();
+  todayStart.setHours(0, 0, 0, 0);
+  const last24h = now - 24 * 60 * 60 * 1e3;
+  const totalRow = stateDb2.db.prepare(
+    "SELECT COUNT(*) as count FROM index_events"
+  ).get();
+  const todayRow = stateDb2.db.prepare(
+    "SELECT COUNT(*) as count FROM index_events WHERE timestamp >= ?"
+  ).get(todayStart.getTime());
+  const last24hRow = stateDb2.db.prepare(
+    "SELECT COUNT(*) as count FROM index_events WHERE timestamp >= ?"
+  ).get(last24h);
+  const avgRow = stateDb2.db.prepare(
+    "SELECT AVG(duration_ms) as avg_ms FROM index_events WHERE success = 1"
+  ).get();
+  const failureRow = stateDb2.db.prepare(
+    "SELECT COUNT(*) as count FROM index_events WHERE success = 0"
+  ).get();
+  const lastRow = stateDb2.db.prepare(
+    "SELECT * FROM index_events ORDER BY timestamp DESC LIMIT 1"
+  ).get();
+  return {
+    total_rebuilds: totalRow.count,
+    last_rebuild: lastRow ? rowToEvent(lastRow) : null,
+    rebuilds_today: todayRow.count,
+    rebuilds_last_24h: last24hRow.count,
+    avg_duration_ms: Math.round(avgRow.avg_ms ?? 0),
+    failure_count: failureRow.count
+  };
+}
+function purgeOldIndexEvents(stateDb2, retentionDays = 90) {
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+  const result = stateDb2.db.prepare(
+    "DELETE FROM index_events WHERE timestamp < ?"
+  ).run(cutoff);
+  return result.changes;
+}
+
 // src/tools/read/health.ts
 var STALE_THRESHOLD_SECONDS = 300;
-function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () => ({})) {
+function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () => ({}), getStateDb = () => null) {
   const IndexProgressSchema = z3.object({
     parsed: z3.coerce.number().describe("Number of files parsed so far"),
     total: z3.coerce.number().describe("Total number of files to parse")
@@ -6217,6 +6291,12 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
     tag_count: z3.coerce.number().describe("Number of unique tags"),
     periodic_notes: z3.array(PeriodicNoteInfoSchema).optional().describe("Detected periodic note conventions"),
     config: z3.record(z3.unknown()).optional().describe("Current flywheel config (paths, templates, etc.)"),
+    last_rebuild: z3.object({
+      trigger: z3.string(),
+      timestamp: z3.number(),
+      duration_ms: z3.number(),
+      ago_seconds: z3.number()
+    }).optional().describe("Most recent index rebuild event"),
     recommendations: z3.array(z3.string()).describe("Suggested actions if any issues detected")
   };
   server2.registerTool(
@@ -6285,6 +6365,23 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       }
       const config = getConfig();
       const configInfo = Object.keys(config).length > 0 ? config : void 0;
+      let lastRebuild;
+      const stateDb2 = getStateDb();
+      if (stateDb2) {
+        try {
+          const events = getRecentIndexEvents(stateDb2, 1);
+          if (events.length > 0) {
+            const event = events[0];
+            lastRebuild = {
+              trigger: event.trigger,
+              timestamp: event.timestamp,
+              duration_ms: event.duration_ms,
+              ago_seconds: Math.floor((Date.now() - event.timestamp) / 1e3)
+            };
+          }
+        } catch {
+        }
+      }
       const output = {
         status,
         vault_accessible: vaultAccessible,
@@ -6300,6 +6397,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         tag_count: tagCount,
         periodic_notes: periodicNotes && periodicNotes.length > 0 ? periodicNotes : void 0,
         config: configInfo,
+        last_rebuild: lastRebuild,
         recommendations
       };
       return {
@@ -6737,12 +6835,20 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
         } catch (err) {
           console.error("[Flywheel] FTS5 rebuild failed:", err);
         }
+        const duration = Date.now() - startTime;
+        if (stateDb2) {
+          recordIndexEvent(stateDb2, {
+            trigger: "manual_refresh",
+            duration_ms: duration,
+            note_count: newIndex.notes.size
+          });
+        }
         const output = {
           success: true,
           notes_count: newIndex.notes.size,
           entities_count: newIndex.entities.size,
           fts5_notes: fts5Notes,
-          duration_ms: Date.now() - startTime
+          duration_ms: duration
         };
         return {
           content: [
@@ -6756,12 +6862,22 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       } catch (err) {
         setIndexState("error");
         setIndexError(err instanceof Error ? err : new Error(String(err)));
+        const duration = Date.now() - startTime;
+        const stateDb2 = getStateDb?.();
+        if (stateDb2) {
+          recordIndexEvent(stateDb2, {
+            trigger: "manual_refresh",
+            duration_ms: duration,
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
         const output = {
           success: false,
           notes_count: 0,
           entities_count: 0,
           fts5_notes: 0,
-          duration_ms: Date.now() - startTime
+          duration_ms: duration
         };
         return {
           content: [
@@ -12377,14 +12493,15 @@ 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 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.',
+      description: 'Track vault growth over time. Modes: "current" (live snapshot), "history" (time series), "trends" (deltas vs N days ago), "index_activity" (rebuild history). 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"),
+        mode: z21.enum(["current", "history", "trends", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
         metric: z21.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
-        days_back: z21.number().optional().describe("Number of days to look back for history/trends (default: 30)")
+        days_back: z21.number().optional().describe("Number of days to look back for history/trends (default: 30)"),
+        limit: z21.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
       }
     },
-    async ({ mode, metric, days_back }) => {
+    async ({ mode, metric, days_back, limit: eventLimit }) => {
       const index = getIndex();
       const stateDb2 = getStateDb();
       const daysBack = days_back ?? 30;
@@ -12426,6 +12543,20 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
           };
           break;
         }
+        case "index_activity": {
+          if (!stateDb2) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available for index activity queries" }) }]
+            };
+          }
+          const summary = getIndexActivitySummary(stateDb2);
+          const recentEvents = getRecentIndexEvents(stateDb2, eventLimit ?? 20);
+          result = {
+            mode: "index_activity",
+            index_activity: { summary, recent_events: recentEvents }
+          };
+          break;
+        }
       }
       return {
         content: [
@@ -12709,7 +12840,7 @@ if (_originalRegisterTool) {
 }
 var categoryList = Array.from(enabledCategories).sort().join(", ");
 console.error(`[Memory] Tool categories: ${categoryList}`);
-registerHealthTools(server, () => vaultIndex, () => vaultPath, () => flywheelConfig);
+registerHealthTools(server, () => vaultIndex, () => vaultPath, () => flywheelConfig, () => stateDb);
 registerSystemTools(
   server,
   () => vaultIndex,
@@ -12786,6 +12917,13 @@ async function main() {
     setIndexState("ready");
     const duration = Date.now() - startTime;
     console.error(`[Memory] Index loaded from cache in ${duration}ms`);
+    if (stateDb) {
+      recordIndexEvent(stateDb, {
+        trigger: "startup_cache",
+        duration_ms: duration,
+        note_count: cachedIndex.notes.size
+      });
+    }
     runPostIndexWork(vaultIndex);
   } else {
     console.error("[Memory] Building vault index...");
@@ -12794,6 +12932,13 @@ async function main() {
       setIndexState("ready");
       const duration = Date.now() - startTime;
       console.error(`[Memory] Vault index ready in ${duration}ms`);
+      if (stateDb) {
+        recordIndexEvent(stateDb, {
+          trigger: "startup_build",
+          duration_ms: duration,
+          note_count: vaultIndex.notes.size
+        });
+      }
       if (stateDb) {
         try {
           saveVaultIndexToCache(stateDb, vaultIndex);
@@ -12806,6 +12951,15 @@ async function main() {
     } catch (err) {
       setIndexState("error");
       setIndexError(err instanceof Error ? err : new Error(String(err)));
+      const duration = Date.now() - startTime;
+      if (stateDb) {
+        recordIndexEvent(stateDb, {
+          trigger: "startup_build",
+          duration_ms: duration,
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
       console.error("[Memory] Failed to build vault index:", err);
     }
   }
@@ -12850,6 +13004,7 @@ async function runPostIndexWork(index) {
       const metrics = computeMetrics(index, stateDb);
       recordMetrics(stateDb, metrics);
       purgeOldMetrics(stateDb, 90);
+      purgeOldIndexEvents(stateDb, 90);
       console.error("[Memory] Growth metrics recorded");
     } catch (err) {
       console.error("[Memory] Failed to record metrics:", err);
@@ -12872,87 +13027,65 @@ async function runPostIndexWork(index) {
     console.error(`[Memory] Vault: ${flywheelConfig.vault_name}`);
   }
   if (process.env.FLYWHEEL_WATCH !== "false") {
-    const useV2Watcher = process.env.FLYWHEEL_WATCH_V2 === "true" || process.env.FLYWHEEL_WATCH_POLL === "true";
-    if (useV2Watcher) {
-      const config = parseWatcherConfig();
-      console.error(`[Memory] File watcher v2 enabled (debounce: ${config.debounceMs}ms)`);
-      const watcher = createVaultWatcher({
-        vaultPath,
-        config,
-        onBatch: async (batch) => {
-          console.error(`[Memory] Processing ${batch.events.length} file changes`);
-          const startTime = Date.now();
-          try {
-            vaultIndex = await buildVaultIndex(vaultPath);
-            setIndexState("ready");
-            console.error(`[Memory] Index rebuilt in ${Date.now() - startTime}ms`);
-            await updateEntitiesInStateDb();
-            await exportHubScores(vaultIndex, stateDb);
-            if (stateDb) {
-              try {
-                saveVaultIndexToCache(stateDb, vaultIndex);
-              } catch (err) {
-                console.error("[Memory] Failed to update index cache:", err);
-              }
+    const config = parseWatcherConfig();
+    console.error(`[Memory] File watcher enabled (debounce: ${config.debounceMs}ms)`);
+    const watcher = createVaultWatcher({
+      vaultPath,
+      config,
+      onBatch: async (batch) => {
+        console.error(`[Memory] Processing ${batch.events.length} file changes`);
+        const batchStart = Date.now();
+        const changedPaths = batch.events.map((e) => e.path);
+        try {
+          vaultIndex = await buildVaultIndex(vaultPath);
+          setIndexState("ready");
+          const duration = Date.now() - batchStart;
+          console.error(`[Memory] Index rebuilt in ${duration}ms`);
+          if (stateDb) {
+            recordIndexEvent(stateDb, {
+              trigger: "watcher",
+              duration_ms: duration,
+              note_count: vaultIndex.notes.size,
+              files_changed: batch.events.length,
+              changed_paths: changedPaths
+            });
+          }
+          await updateEntitiesInStateDb();
+          await exportHubScores(vaultIndex, stateDb);
+          if (stateDb) {
+            try {
+              saveVaultIndexToCache(stateDb, vaultIndex);
+            } catch (err) {
+              console.error("[Memory] Failed to update index cache:", err);
             }
-          } catch (err) {
-            setIndexState("error");
-            setIndexError(err instanceof Error ? err : new Error(String(err)));
-            console.error("[Memory] Failed to rebuild index:", err);
           }
-        },
-        onStateChange: (status) => {
-          if (status.state === "dirty") {
-            console.error("[Memory] Warning: Index may be stale");
+        } catch (err) {
+          setIndexState("error");
+          setIndexError(err instanceof Error ? err : new Error(String(err)));
+          const duration = Date.now() - batchStart;
+          if (stateDb) {
+            recordIndexEvent(stateDb, {
+              trigger: "watcher",
+              duration_ms: duration,
+              success: false,
+              files_changed: batch.events.length,
+              changed_paths: changedPaths,
+              error: err instanceof Error ? err.message : String(err)
+            });
           }
-        },
-        onError: (err) => {
-          console.error("[Memory] Watcher error:", err.message);
+          console.error("[Memory] Failed to rebuild index:", err);
         }
-      });
-      watcher.start();
-    } else {
-      const debounceMs = parseInt(process.env.FLYWHEEL_DEBOUNCE_MS || "60000");
-      console.error(`[Memory] File watcher v1 enabled (debounce: ${debounceMs}ms)`);
-      if (debounceMs >= 6e4) {
-        console.error("[Memory] Warning: Legacy watcher using high debounce (60s). Set FLYWHEEL_WATCH_V2=true for 200ms responsiveness.");
-      }
-      const legacyWatcher = chokidar2.watch(vaultPath, {
-        ignored: /(^|[\/\\])\../,
-        persistent: true,
-        ignoreInitial: true,
-        awaitWriteFinish: {
-          stabilityThreshold: 300,
-          pollInterval: 100
+      },
+      onStateChange: (status) => {
+        if (status.state === "dirty") {
+          console.error("[Memory] Warning: Index may be stale");
         }
-      });
-      let rebuildTimer;
-      legacyWatcher.on("all", (event, path25) => {
-        if (!path25.endsWith(".md")) return;
-        clearTimeout(rebuildTimer);
-        rebuildTimer = setTimeout(() => {
-          console.error("[Memory] Rebuilding index (file changed)");
-          buildVaultIndex(vaultPath).then(async (newIndex) => {
-            vaultIndex = newIndex;
-            setIndexState("ready");
-            console.error("[Memory] Index rebuilt successfully");
-            await updateEntitiesInStateDb();
-            await exportHubScores(newIndex, stateDb);
-            if (stateDb) {
-              try {
-                saveVaultIndexToCache(stateDb, newIndex);
-              } catch (err) {
-                console.error("[Memory] Failed to update index cache:", err);
-              }
-            }
-          }).catch((err) => {
-            setIndexState("error");
-            setIndexError(err instanceof Error ? err : new Error(String(err)));
-            console.error("[Memory] Failed to rebuild index:", err);
-          });
-        }, debounceMs);
-      });
-    }
+      },
+      onError: (err) => {
+        console.error("[Memory] Watcher error:", err.message);
+      }
+    });
+    watcher.start();
   }
 }
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. 39 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.16",
+    "@velvetmonkey/vault-core": "^2.0.18",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",