@velvetmonkey/flywheel-mcp 1.25.5 → 1.26.2

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import chokidar from "chokidar";
+import chokidar2 from "chokidar";
 
 // src/core/vault.ts
 import * as fs from "fs";
@@ -260,8 +260,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path11) {
-  return path11.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path12) {
+  return path12.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -455,7 +455,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path11] of index.entities) {
+  for (const [entity, path12] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -463,7 +463,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path11, entity, distance: dist };
+        bestMatch = { path: path12, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -889,14 +889,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path11] of entities) {
+    for (const [name, path12] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path11;
+        return path12;
       }
     }
-    for (const [name, path11] of entities) {
+    for (const [name, path12] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path11;
+        return path12;
       }
     }
     return void 0;
@@ -1193,8 +1193,8 @@ function registerHealthTools(server2, getIndex, getVaultPath) {
     top_tags: z3.array(TagStatSchema).describe("Top 20 most used tags"),
     folders: z3.array(FolderStatSchema).describe("Note counts by top-level folder")
   };
-  function isPeriodicNote(path11) {
-    const filename = path11.split("/").pop() || "";
+  function isPeriodicNote(path12) {
+    const filename = path12.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -1209,7 +1209,7 @@ function registerHealthTools(server2, getIndex, getVaultPath) {
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path11.split("/")[0]?.toLowerCase() || "";
+    const folder = path12.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -2131,8 +2131,8 @@ function getStaleNotes(index, days, minBacklinks = 0) {
     return b.days_since_modified - a.days_since_modified;
   });
 }
-function getContemporaneousNotes(index, path11, hours = 24) {
-  const targetNote = index.notes.get(path11);
+function getContemporaneousNotes(index, path12, hours = 24) {
+  const targetNote = index.notes.get(path12);
   if (!targetNote) {
     return [];
   }
@@ -2140,7 +2140,7 @@ function getContemporaneousNotes(index, path11, hours = 24) {
   const windowMs = hours * 60 * 60 * 1e3;
   const results = [];
   for (const note of index.notes.values()) {
-    if (note.path === path11) continue;
+    if (note.path === path12) continue;
     const timeDiff = Math.abs(note.modified.getTime() - targetTime);
     if (timeDiff <= windowMs) {
       results.push({
@@ -2932,14 +2932,14 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path11, hours, limit: requestedLimit, offset }) => {
+    async ({ path: path12, hours, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
-      const allResults = getContemporaneousNotes(index, path11, hours);
+      const allResults = getContemporaneousNotes(index, path12, hours);
       const result = allResults.slice(offset, offset + limit);
       return {
         content: [{ type: "text", text: JSON.stringify({
-          reference_note: path11,
+          reference_note: path12,
           window_hours: hours,
           total_count: allResults.length,
           returned_count: result.length,
@@ -2977,13 +2977,13 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path11 }) => {
+    async ({ path: path12 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path11, vaultPath2);
+      const result = await getNoteStructure(index, path12, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path11 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path12 }, null, 2) }]
         };
       }
       return {
@@ -3000,18 +3000,18 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path11 }) => {
+    async ({ path: path12 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getHeadings(index, path11, vaultPath2);
+      const result = await getHeadings(index, path12, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path11 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path12 }, null, 2) }]
         };
       }
       return {
         content: [{ type: "text", text: JSON.stringify({
-          path: path11,
+          path: path12,
           heading_count: result.length,
           headings: result
         }, null, 2) }]
@@ -3029,15 +3029,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path11, heading, include_subheadings }) => {
+    async ({ path: path12, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path11, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path12, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path11,
+            path: path12,
             heading
           }, null, 2) }]
         };
@@ -3114,19 +3114,19 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path11 }) => {
+    async ({ path: path12 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config = getConfig();
-      const result = await getTasksFromNote(index, path11, vaultPath2, config.exclude_task_tags || []);
+      const result = await getTasksFromNote(index, path12, vaultPath2, config.exclude_task_tags || []);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path11 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path12 }, null, 2) }]
         };
       }
       return {
         content: [{ type: "text", text: JSON.stringify({
-          path: path11,
+          path: path12,
           task_count: result.length,
           open: result.filter((t) => t.status === "open").length,
           completed: result.filter((t) => t.status === "completed").length,
@@ -3258,14 +3258,14 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path11, limit: requestedLimit, offset }) => {
+    async ({ path: path12, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
-      const allResults = findBidirectionalLinks(index, path11);
+      const allResults = findBidirectionalLinks(index, path12);
       const result = allResults.slice(offset, offset + limit);
       return {
         content: [{ type: "text", text: JSON.stringify({
-          scope: path11 || "all",
+          scope: path12 || "all",
           total_count: allResults.length,
           returned_count: result.length,
           pairs: result
@@ -4806,6 +4806,462 @@ function findVaultRoot(startPath) {
   }
 }
 
+// src/core/watch/index.ts
+import chokidar from "chokidar";
+
+// src/core/watch/pathFilter.ts
+import path11 from "path";
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".obsidian",
+  ".trash",
+  ".Trash",
+  "node_modules",
+  ".vscode",
+  ".idea",
+  "__pycache__",
+  ".cache",
+  ".claude"
+]);
+var IGNORED_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Images
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".svg",
+  ".ico",
+  ".bmp",
+  ".tiff",
+  // Documents
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  // Audio/Video
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".mov",
+  ".avi",
+  ".mkv",
+  // Archives
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  // Temp/System
+  ".tmp",
+  ".temp",
+  ".swp",
+  ".swo",
+  ".bak",
+  // Data
+  ".json",
+  ".yaml",
+  ".yml",
+  ".xml",
+  ".csv",
+  // Code (not markdown)
+  ".js",
+  ".ts",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".c",
+  ".cpp",
+  ".h",
+  // Other
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib"
+]);
+var IGNORED_PATTERNS = [
+  /^\.#/,
+  // Emacs lock files (.#filename)
+  /~$/,
+  // Backup files (filename~)
+  /^#.*#$/,
+  // Emacs auto-save (#filename#)
+  /\.orig$/,
+  // Merge conflict originals
+  /\.swp$/,
+  // Vim swap files
+  /\.DS_Store$/,
+  // macOS metadata
+  /^Thumbs\.db$/i,
+  // Windows thumbnail cache
+  /^desktop\.ini$/i
+  // Windows folder settings
+];
+function isIgnoredDirectory(segment) {
+  return IGNORED_DIRECTORIES.has(segment);
+}
+function hasIgnoredExtension(filePath) {
+  const ext = path11.extname(filePath).toLowerCase();
+  return IGNORED_EXTENSIONS.has(ext);
+}
+function matchesIgnoredPattern(filename) {
+  return IGNORED_PATTERNS.some((pattern) => pattern.test(filename));
+}
+function normalizePath(filePath) {
+  let normalized = filePath.replace(/\\/g, "/");
+  if (process.platform === "win32") {
+    normalized = normalized.toLowerCase();
+  }
+  return normalized;
+}
+function getRelativePath(vaultPath2, filePath) {
+  const relative = path11.relative(vaultPath2, filePath);
+  return normalizePath(relative);
+}
+function shouldWatch(filePath, vaultPath2) {
+  const normalized = normalizePath(filePath);
+  const relativePath = vaultPath2 ? getRelativePath(vaultPath2, filePath) : normalized;
+  const segments = relativePath.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    return false;
+  }
+  for (const segment of segments.slice(0, -1)) {
+    if (isIgnoredDirectory(segment)) {
+      return false;
+    }
+  }
+  const filename = segments[segments.length - 1];
+  if (!filename.toLowerCase().endsWith(".md")) {
+    return false;
+  }
+  if (hasIgnoredExtension(filename)) {
+    return false;
+  }
+  if (matchesIgnoredPattern(filename)) {
+    return false;
+  }
+  if (filename.startsWith(".")) {
+    return false;
+  }
+  return true;
+}
+function createIgnoreFunction(vaultPath2) {
+  return (filePath) => {
+    return !shouldWatch(filePath, vaultPath2);
+  };
+}
+
+// src/core/watch/eventQueue.ts
+function coalesceEvents(events) {
+  if (events.length === 0) return null;
+  const types = events.map((e) => e.type);
+  const lastUnlink = types.lastIndexOf("unlink");
+  const lastAdd = types.lastIndexOf("add");
+  const lastChange = types.lastIndexOf("change");
+  if (lastUnlink > lastAdd && lastUnlink > lastChange) {
+    return "delete";
+  }
+  if (lastAdd >= 0 || lastChange >= 0) {
+    return "upsert";
+  }
+  if (types.every((t) => t === "unlink")) {
+    return "delete";
+  }
+  return null;
+}
+var EventQueue = class {
+  pending = /* @__PURE__ */ new Map();
+  config;
+  flushTimer = null;
+  onBatch;
+  constructor(config, onBatch) {
+    this.config = config;
+    this.onBatch = onBatch;
+  }
+  /**
+   * Add a new event to the queue
+   */
+  push(type, rawPath) {
+    const path12 = normalizePath(rawPath);
+    const now = Date.now();
+    const event = {
+      type,
+      path: path12,
+      timestamp: now
+    };
+    let pending = this.pending.get(path12);
+    if (!pending) {
+      pending = {
+        events: [],
+        timer: null,
+        lastEvent: now
+      };
+      this.pending.set(path12, pending);
+    }
+    pending.events.push(event);
+    pending.lastEvent = now;
+    if (pending.timer) {
+      clearTimeout(pending.timer);
+    }
+    pending.timer = setTimeout(() => {
+      this.flushPath(path12);
+    }, this.config.debounceMs);
+    if (this.pending.size >= this.config.batchSize) {
+      this.flush();
+      return;
+    }
+    this.ensureFlushTimer();
+  }
+  /**
+   * Ensure the global flush timer is running
+   */
+  ensureFlushTimer() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flush();
+    }, this.config.flushMs);
+  }
+  /**
+   * Flush a single path's events
+   */
+  flushPath(path12) {
+    const pending = this.pending.get(path12);
+    if (!pending || pending.events.length === 0) return;
+    if (pending.timer) {
+      clearTimeout(pending.timer);
+      pending.timer = null;
+    }
+    const coalescedType = coalesceEvents(pending.events);
+    if (coalescedType) {
+      const coalesced = {
+        type: coalescedType,
+        path: path12,
+        originalEvents: [...pending.events]
+      };
+      this.onBatch({
+        events: [coalesced],
+        timestamp: Date.now()
+      });
+    }
+    this.pending.delete(path12);
+  }
+  /**
+   * Flush all pending events
+   */
+  flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.pending.size === 0) return;
+    const events = [];
+    for (const [path12, pending] of this.pending) {
+      if (pending.timer) {
+        clearTimeout(pending.timer);
+      }
+      const coalescedType = coalesceEvents(pending.events);
+      if (coalescedType) {
+        events.push({
+          type: coalescedType,
+          path: path12,
+          originalEvents: [...pending.events]
+        });
+      }
+    }
+    this.pending.clear();
+    if (events.length > 0) {
+      this.onBatch({
+        events,
+        timestamp: Date.now()
+      });
+    }
+  }
+  /**
+   * Get the number of pending paths
+   */
+  get size() {
+    return this.pending.size;
+  }
+  /**
+   * Get the total number of pending events
+   */
+  get eventCount() {
+    let count = 0;
+    for (const pending of this.pending.values()) {
+      count += pending.events.length;
+    }
+    return count;
+  }
+  /**
+   * Clear all pending events without processing
+   */
+  clear() {
+    for (const pending of this.pending.values()) {
+      if (pending.timer) {
+        clearTimeout(pending.timer);
+      }
+    }
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.pending.clear();
+  }
+  /**
+   * Dispose the queue
+   */
+  dispose() {
+    this.clear();
+  }
+};
+
+// src/core/watch/types.ts
+var DEFAULT_WATCHER_CONFIG = {
+  debounceMs: 200,
+  flushMs: 1e3,
+  batchSize: 50,
+  usePolling: false,
+  pollInterval: 500
+};
+function parseWatcherConfig() {
+  const debounceMs = parseInt(process.env.FLYWHEEL_DEBOUNCE_MS || "");
+  const flushMs = parseInt(process.env.FLYWHEEL_FLUSH_MS || "");
+  const batchSize = parseInt(process.env.FLYWHEEL_BATCH_SIZE || "");
+  const usePolling = process.env.FLYWHEEL_WATCH_POLL === "true";
+  const pollInterval = parseInt(process.env.FLYWHEEL_POLL_INTERVAL || "");
+  return {
+    debounceMs: Number.isFinite(debounceMs) && debounceMs > 0 ? debounceMs : DEFAULT_WATCHER_CONFIG.debounceMs,
+    flushMs: Number.isFinite(flushMs) && flushMs > 0 ? flushMs : DEFAULT_WATCHER_CONFIG.flushMs,
+    batchSize: Number.isFinite(batchSize) && batchSize > 0 ? batchSize : DEFAULT_WATCHER_CONFIG.batchSize,
+    usePolling,
+    pollInterval: Number.isFinite(pollInterval) && pollInterval > 0 ? pollInterval : DEFAULT_WATCHER_CONFIG.pollInterval
+  };
+}
+
+// src/core/watch/index.ts
+function createVaultWatcher(options) {
+  const { vaultPath: vaultPath2, onBatch, onStateChange, onError } = options;
+  const config = {
+    ...DEFAULT_WATCHER_CONFIG,
+    ...parseWatcherConfig(),
+    ...options.config
+  };
+  let state = "starting";
+  let lastRebuild = null;
+  let error = null;
+  let watcher = null;
+  let processingBatch = false;
+  let pendingBatches = [];
+  const getStatus = () => ({
+    state,
+    pendingEvents: eventQueue?.eventCount || 0,
+    lastRebuild,
+    error
+  });
+  const setState = (newState, newError = null) => {
+    state = newState;
+    error = newError;
+    onStateChange?.(getStatus());
+  };
+  const processBatch2 = async (batch) => {
+    if (processingBatch) {
+      pendingBatches.push(batch);
+      return;
+    }
+    processingBatch = true;
+    setState("rebuilding");
+    try {
+      await onBatch(batch);
+      lastRebuild = Date.now();
+      setState("ready");
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setState("error", e);
+      onError?.(e);
+    } finally {
+      processingBatch = false;
+      if (pendingBatches.length > 0) {
+        const nextBatch = pendingBatches.shift();
+        setImmediate(() => processBatch2(nextBatch));
+      }
+    }
+  };
+  const eventQueue = new EventQueue(config, processBatch2);
+  const instance = {
+    get status() {
+      return getStatus();
+    },
+    get pendingCount() {
+      return eventQueue.eventCount + pendingBatches.reduce((sum, b) => sum + b.events.length, 0);
+    },
+    start() {
+      if (watcher) {
+        console.error("[flywheel] Watcher already started");
+        return;
+      }
+      console.error(`[flywheel] Starting file watcher (debounce: ${config.debounceMs}ms, flush: ${config.flushMs}ms)`);
+      watcher = chokidar.watch(vaultPath2, {
+        ignored: createIgnoreFunction(vaultPath2),
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+          stabilityThreshold: 300,
+          pollInterval: 100
+        },
+        usePolling: config.usePolling,
+        interval: config.usePolling ? config.pollInterval : void 0
+      });
+      watcher.on("add", (path12) => {
+        if (shouldWatch(path12, vaultPath2)) {
+          eventQueue.push("add", path12);
+        }
+      });
+      watcher.on("change", (path12) => {
+        if (shouldWatch(path12, vaultPath2)) {
+          eventQueue.push("change", path12);
+        }
+      });
+      watcher.on("unlink", (path12) => {
+        if (shouldWatch(path12, vaultPath2)) {
+          eventQueue.push("unlink", path12);
+        }
+      });
+      watcher.on("ready", () => {
+        console.error("[flywheel] File watcher ready");
+        setState("ready");
+      });
+      watcher.on("error", (err) => {
+        console.error("[flywheel] Watcher error:", err);
+        const e = err instanceof Error ? err : new Error(String(err));
+        setState("error", e);
+        onError?.(e);
+      });
+    },
+    stop() {
+      if (!watcher) {
+        return;
+      }
+      console.error("[flywheel] Stopping file watcher");
+      eventQueue.flush();
+      watcher.close();
+      watcher = null;
+      eventQueue.dispose();
+    },
+    flush() {
+      eventQueue.flush();
+    }
+  };
+  return instance;
+}
+
 // src/index.ts
 var vaultPath = process.env.PROJECT_PATH || findVaultRoot();
 var flywheelConfig = {};
@@ -4930,35 +5386,66 @@ async function main() {
       console.error(`[Flywheel] Excluding task tags: ${flywheelConfig.exclude_task_tags.join(", ")}`);
     }
     if (process.env.FLYWHEEL_WATCH === "true") {
-      const debounceMs = parseInt(process.env.FLYWHEEL_DEBOUNCE_MS || "60000");
-      console.error(`[flywheel] File watcher enabled (debounce: ${debounceMs}ms)`);
-      const watcher = chokidar.watch(vaultPath, {
-        ignored: /(^|[\/\\])\../,
-        // ignore dotfiles
-        persistent: true,
-        ignoreInitial: true,
-        awaitWriteFinish: {
-          stabilityThreshold: 300,
-          pollInterval: 100
-        }
-      });
-      let rebuildTimer;
-      watcher.on("all", (event, path11) => {
-        if (!path11.endsWith(".md")) return;
-        clearTimeout(rebuildTimer);
-        rebuildTimer = setTimeout(() => {
-          console.error("[flywheel] Rebuilding index (file changed)");
-          buildVaultIndex(vaultPath).then((index2) => {
-            vaultIndex = index2;
-            setIndexState("ready");
-            console.error("[flywheel] Index rebuilt successfully");
-          }).catch((err) => {
-            setIndexState("error");
-            setIndexError(err instanceof Error ? err : new Error(String(err)));
-            console.error("[flywheel] Failed to rebuild index:", err);
-          });
-        }, debounceMs);
-      });
+      if (process.env.FLYWHEEL_WATCH_V2 === "true") {
+        const config = parseWatcherConfig();
+        console.error(`[flywheel] File watcher v2 enabled (debounce: ${config.debounceMs}ms, flush: ${config.flushMs}ms)`);
+        const watcher = createVaultWatcher({
+          vaultPath,
+          config,
+          onBatch: async (batch) => {
+            console.error(`[flywheel] Processing ${batch.events.length} file changes`);
+            const startTime2 = Date.now();
+            try {
+              vaultIndex = await buildVaultIndex(vaultPath);
+              setIndexState("ready");
+              console.error(`[flywheel] Index rebuilt in ${Date.now() - startTime2}ms`);
+            } catch (err) {
+              setIndexState("error");
+              setIndexError(err instanceof Error ? err : new Error(String(err)));
+              console.error("[flywheel] Failed to rebuild index:", err);
+            }
+          },
+          onStateChange: (status) => {
+            if (status.state === "dirty") {
+              console.error("[flywheel] Warning: Index may be stale");
+            }
+          },
+          onError: (err) => {
+            console.error("[flywheel] Watcher error:", err.message);
+          }
+        });
+        watcher.start();
+      } else {
+        const debounceMs = parseInt(process.env.FLYWHEEL_DEBOUNCE_MS || "60000");
+        console.error(`[flywheel] File watcher v1 enabled (debounce: ${debounceMs}ms)`);
+        const legacyWatcher = chokidar2.watch(vaultPath, {
+          ignored: /(^|[\/\\])\../,
+          // ignore dotfiles
+          persistent: true,
+          ignoreInitial: true,
+          awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100
+          }
+        });
+        let rebuildTimer;
+        legacyWatcher.on("all", (event, path12) => {
+          if (!path12.endsWith(".md")) return;
+          clearTimeout(rebuildTimer);
+          rebuildTimer = setTimeout(() => {
+            console.error("[flywheel] Rebuilding index (file changed)");
+            buildVaultIndex(vaultPath).then((index2) => {
+              vaultIndex = index2;
+              setIndexState("ready");
+              console.error("[flywheel] Index rebuilt successfully");
+            }).catch((err) => {
+              setIndexState("error");
+              setIndexError(err instanceof Error ? err : new Error(String(err)));
+              console.error("[flywheel] Failed to rebuild index:", err);
+            });
+          }, debounceMs);
+        });
+      }
     }
   }).catch((err) => {
     setIndexState("error");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-mcp",
-  "version": "1.25.5",
+  "version": "1.26.2",
   "description": "Query your markdown like a database. 100x token savings for AI agents.",
   "type": "module",
   "main": "dist/index.js",