@velvetmonkey/flywheel-mcp 1.27.19 → 1.27.20

package/dist/index.js

@@ -248,8 +248,8 @@ function getIndexProgress() {
 function getIndexError() {
   return indexError;
 }
-function setIndexState(state) {
-  indexState = state;
+function setIndexState(state2) {
+  indexState = state2;
 }
 function setIndexError(error) {
   indexError = error;
@@ -260,8 +260,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path13) {
-  return path13.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path14) {
+  return path14.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, path13] of index.entities) {
+  for (const [entity, path14] 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: path13, entity, distance: dist };
+        bestMatch = { path: path14, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -483,13 +483,13 @@ var MAX_LIMIT = 200;
 
 // src/core/indexGuard.ts
 function requireIndex() {
-  const state = getIndexState();
-  if (state === "building") {
+  const state2 = getIndexState();
+  if (state2 === "building") {
     const { parsed, total } = getIndexProgress();
     const progress = total > 0 ? ` (${parsed}/${total} files)` : "";
     throw new Error(`Index building${progress}... try again shortly`);
   }
-  if (state === "error") {
+  if (state2 === "error") {
     const error = getIndexError();
     throw new Error(`Index failed to build: ${error?.message || "unknown error"}`);
   }
@@ -889,14 +889,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path13] of entities) {
+    for (const [name, path14] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path13;
+        return path14;
       }
     }
-    for (const [name, path13] of entities) {
+    for (const [name, path14] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path13;
+        return path14;
       }
     }
     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(path13) {
-    const filename = path13.split("/").pop() || "";
+  function isPeriodicNote(path14) {
+    const filename = path14.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 = path13.split("/")[0]?.toLowerCase() || "";
+    const folder = path14.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -1302,6 +1302,166 @@ function registerHealthTools(server2, getIndex, getVaultPath) {
 
 // src/tools/query.ts
 import { z as z4 } from "zod";
+
+// src/core/fts5.ts
+import Database from "better-sqlite3";
+import * as fs5 from "fs";
+import * as path3 from "path";
+var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set([
+  ".obsidian",
+  ".trash",
+  ".git",
+  "node_modules",
+  "templates",
+  ".claude"
+]);
+var MAX_INDEX_FILE_SIZE = 5 * 1024 * 1024;
+var STALE_THRESHOLD_MS = 60 * 60 * 1e3;
+var db = null;
+var state = {
+  ready: false,
+  lastBuilt: null,
+  noteCount: 0,
+  error: null
+};
+function getDbPath(vaultPath2) {
+  const claudeDir = path3.join(vaultPath2, ".claude");
+  if (!fs5.existsSync(claudeDir)) {
+    fs5.mkdirSync(claudeDir, { recursive: true });
+  }
+  return path3.join(claudeDir, "vault-search.db");
+}
+function initDatabase(vaultPath2) {
+  const dbPath = getDbPath(vaultPath2);
+  const database = new Database(dbPath);
+  database.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
+      path,
+      title,
+      content,
+      tokenize='porter'
+    );
+
+    CREATE TABLE IF NOT EXISTS fts_metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+  `);
+  return database;
+}
+function shouldIndexFile(filePath) {
+  const parts = filePath.split("/");
+  return !parts.some((part) => EXCLUDED_DIRS2.has(part));
+}
+async function buildFTS5Index(vaultPath2) {
+  try {
+    state.error = null;
+    db = initDatabase(vaultPath2);
+    db.exec("DELETE FROM notes_fts");
+    const files = await scanVault(vaultPath2);
+    const indexableFiles = files.filter((f) => shouldIndexFile(f.path));
+    const insert = db.prepare(
+      "INSERT INTO notes_fts (path, title, content) VALUES (?, ?, ?)"
+    );
+    const insertMany = db.transaction((filesToIndex) => {
+      let indexed2 = 0;
+      for (const file of filesToIndex) {
+        try {
+          const stats = fs5.statSync(file.absolutePath);
+          if (stats.size > MAX_INDEX_FILE_SIZE) {
+            continue;
+          }
+          const content = fs5.readFileSync(file.absolutePath, "utf-8");
+          const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
+          insert.run(file.path, title, content);
+          indexed2++;
+        } catch (err) {
+          console.error(`[FTS5] Skipping ${file.path}:`, err);
+        }
+      }
+      return indexed2;
+    });
+    const indexed = insertMany(indexableFiles);
+    const now = /* @__PURE__ */ new Date();
+    db.prepare(
+      "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)"
+    ).run("last_built", now.toISOString());
+    state = {
+      ready: true,
+      lastBuilt: now,
+      noteCount: indexed,
+      error: null
+    };
+    console.error(`[FTS5] Indexed ${indexed} notes`);
+    return state;
+  } catch (err) {
+    state = {
+      ready: false,
+      lastBuilt: null,
+      noteCount: 0,
+      error: err instanceof Error ? err.message : String(err)
+    };
+    throw err;
+  }
+}
+function isIndexStale(vaultPath2) {
+  const dbPath = getDbPath(vaultPath2);
+  if (!fs5.existsSync(dbPath)) {
+    return true;
+  }
+  try {
+    const database = new Database(dbPath, { readonly: true });
+    const row = database.prepare(
+      "SELECT value FROM fts_metadata WHERE key = ?"
+    ).get("last_built");
+    database.close();
+    if (!row) {
+      return true;
+    }
+    const lastBuilt = new Date(row.value);
+    const age = Date.now() - lastBuilt.getTime();
+    return age > STALE_THRESHOLD_MS;
+  } catch {
+    return true;
+  }
+}
+function ensureDb(vaultPath2) {
+  if (!db) {
+    const dbPath = getDbPath(vaultPath2);
+    if (!fs5.existsSync(dbPath)) {
+      throw new Error("Search index not built. Call rebuild_search_index first.");
+    }
+    db = new Database(dbPath);
+  }
+  return db;
+}
+function searchFTS5(vaultPath2, query, limit = 10) {
+  const database = ensureDb(vaultPath2);
+  try {
+    const stmt = database.prepare(`
+      SELECT
+        path,
+        title,
+        snippet(notes_fts, 2, '[', ']', '...', 20) as snippet
+      FROM notes_fts
+      WHERE notes_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `);
+    const results = stmt.all(query, limit);
+    return results;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("fts5: syntax error")) {
+      throw new Error(`Invalid search query: ${query}. Check FTS5 syntax.`);
+    }
+    throw err;
+  }
+}
+function getFTS5State() {
+  return { ...state };
+}
+
+// src/tools/query.ts
 function matchesFrontmatter(note, where) {
   for (const [key, value] of Object.entries(where)) {
     const noteValue = note.frontmatter[key];
@@ -1480,25 +1640,125 @@ function registerQueryTools(server2, getIndex, getVaultPath) {
       };
     }
   );
+  const FTS5ResultSchema = z4.object({
+    path: z4.string().describe("Path to the note"),
+    title: z4.string().describe("Note title"),
+    snippet: z4.string().describe("Matching snippet with highlighted terms")
+  });
+  const FullTextSearchOutputSchema = {
+    query: z4.string().describe("The search query that was executed"),
+    total_results: z4.number().describe("Number of matching results"),
+    results: z4.array(FTS5ResultSchema).describe("Matching notes with snippets")
+  };
+  server2.registerTool(
+    "full_text_search",
+    {
+      title: "Full-Text Search",
+      description: 'Search note content using SQLite FTS5 full-text search. Supports stemming (running matches run/runs/ran), phrases ("exact phrase"), boolean operators (AND, OR, NOT), and prefix matching (auth*).',
+      inputSchema: {
+        query: z4.string().describe(
+          'Search query. Examples: "authentication", "exact phrase", "term1 AND term2", "prefix*"'
+        ),
+        limit: z4.number().default(10).describe("Maximum number of results to return")
+      },
+      outputSchema: FullTextSearchOutputSchema
+    },
+    async ({
+      query,
+      limit: requestedLimit = 10
+    }) => {
+      const vaultPath2 = getVaultPath();
+      const limit = Math.min(requestedLimit, MAX_LIMIT);
+      const ftsState = getFTS5State();
+      if (!ftsState.ready || isIndexStale(vaultPath2)) {
+        console.error("[FTS5] Index stale or missing, rebuilding...");
+        await buildFTS5Index(vaultPath2);
+      }
+      const results = searchFTS5(vaultPath2, query, limit);
+      const output = {
+        query,
+        total_results: results.length,
+        results
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const RebuildIndexOutputSchema = {
+    status: z4.enum(["success", "error"]).describe("Whether the rebuild succeeded"),
+    notes_indexed: z4.number().describe("Number of notes indexed"),
+    message: z4.string().describe("Status message")
+  };
+  server2.registerTool(
+    "rebuild_search_index",
+    {
+      title: "Rebuild Search Index",
+      description: "Manually rebuild the FTS5 full-text search index. Use this after bulk changes to the vault or if search results seem stale.",
+      inputSchema: {},
+      outputSchema: RebuildIndexOutputSchema
+    },
+    async () => {
+      const vaultPath2 = getVaultPath();
+      try {
+        const state2 = await buildFTS5Index(vaultPath2);
+        const output = {
+          status: "success",
+          notes_indexed: state2.noteCount,
+          message: `Successfully indexed ${state2.noteCount} notes`
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(output, null, 2)
+            }
+          ],
+          structuredContent: output
+        };
+      } catch (err) {
+        const output = {
+          status: "error",
+          notes_indexed: 0,
+          message: err instanceof Error ? err.message : String(err)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(output, null, 2)
+            }
+          ],
+          structuredContent: output
+        };
+      }
+    }
+  );
 }
 
 // src/tools/system.ts
-import * as fs6 from "fs";
-import * as path4 from "path";
+import * as fs7 from "fs";
+import * as path5 from "path";
 import { z as z5 } from "zod";
 
 // src/core/config.ts
-import * as fs5 from "fs";
-import * as path3 from "path";
+import * as fs6 from "fs";
+import * as path4 from "path";
 var DEFAULT_CONFIG = {
   exclude_task_tags: []
 };
 function loadConfig(vaultPath2) {
-  const claudeDir = path3.join(vaultPath2, ".claude");
-  const configPath = path3.join(claudeDir, ".flywheel.json");
+  const claudeDir = path4.join(vaultPath2, ".claude");
+  const configPath = path4.join(claudeDir, ".flywheel.json");
   try {
-    if (fs5.existsSync(configPath)) {
-      const content = fs5.readFileSync(configPath, "utf-8");
+    if (fs6.existsSync(configPath)) {
+      const content = fs6.readFileSync(configPath, "utf-8");
       const config = JSON.parse(content);
       return { ...DEFAULT_CONFIG, ...config };
     }
@@ -1528,7 +1788,7 @@ var FOLDER_PATTERNS = {
 function extractFolders(index) {
   const folders = /* @__PURE__ */ new Set();
   for (const notePath of index.notes.keys()) {
-    const dir = path3.dirname(notePath);
+    const dir = path4.dirname(notePath);
     if (dir && dir !== ".") {
       const parts = dir.split(/[/\\]/);
       for (let i = 1; i <= parts.length; i++) {
@@ -1545,7 +1805,7 @@ function extractFolders(index) {
 function findMatchingFolder(folders, patterns) {
   const lowerPatterns = patterns.map((p) => p.toLowerCase());
   for (const folder of folders) {
-    const folderName = path3.basename(folder).toLowerCase();
+    const folderName = path4.basename(folder).toLowerCase();
     if (lowerPatterns.includes(folderName)) {
       return folder;
     }
@@ -1558,7 +1818,7 @@ function inferConfig(index, vaultPath2) {
     paths: {}
   };
   if (vaultPath2) {
-    inferred.vault_name = path3.basename(vaultPath2);
+    inferred.vault_name = path4.basename(vaultPath2);
   }
   const folders = extractFolders(index);
   const detectedPath = findMatchingFolder(folders, FOLDER_PATTERNS.daily_notes);
@@ -1582,11 +1842,11 @@ function inferConfig(index, vaultPath2) {
   return inferred;
 }
 function saveConfig(vaultPath2, inferred, existing) {
-  const claudeDir = path3.join(vaultPath2, ".claude");
-  const configPath = path3.join(claudeDir, ".flywheel.json");
+  const claudeDir = path4.join(vaultPath2, ".claude");
+  const configPath = path4.join(claudeDir, ".flywheel.json");
   try {
-    if (!fs5.existsSync(claudeDir)) {
-      fs5.mkdirSync(claudeDir, { recursive: true });
+    if (!fs6.existsSync(claudeDir)) {
+      fs6.mkdirSync(claudeDir, { recursive: true });
     }
     const mergedPaths = {
       ...inferred.paths,
@@ -1600,7 +1860,7 @@ function saveConfig(vaultPath2, inferred, existing) {
       ...Object.keys(mergedPaths).length > 0 ? { paths: mergedPaths } : {}
     };
     const content = JSON.stringify(merged, null, 2);
-    fs5.writeFileSync(configPath, content, "utf-8");
+    fs6.writeFileSync(configPath, content, "utf-8");
     console.error(`[Flywheel] Saved .claude/.flywheel.json`);
   } catch (err) {
     console.error("[Flywheel] Failed to save .claude/.flywheel.json:", err);
@@ -1849,8 +2109,8 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path4.join(vaultPath2, note.path);
-          const content = await fs6.promises.readFile(fullPath, "utf-8");
+          const fullPath = path5.join(vaultPath2, note.path);
+          const content = await fs7.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
@@ -1965,8 +2225,8 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       let wordCount;
       if (include_word_count) {
         try {
-          const fullPath = path4.join(vaultPath2, resolvedPath);
-          const content = await fs6.promises.readFile(fullPath, "utf-8");
+          const fullPath = path5.join(vaultPath2, resolvedPath);
+          const content = await fs7.promises.readFile(fullPath, "utf-8");
           wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
         } catch {
         }
@@ -2131,8 +2391,8 @@ function getStaleNotes(index, days, minBacklinks = 0) {
     return b.days_since_modified - a.days_since_modified;
   });
 }
-function getContemporaneousNotes(index, path13, hours = 24) {
-  const targetNote = index.notes.get(path13);
+function getContemporaneousNotes(index, path14, hours = 24) {
+  const targetNote = index.notes.get(path14);
   if (!targetNote) {
     return [];
   }
@@ -2140,7 +2400,7 @@ function getContemporaneousNotes(index, path13, hours = 24) {
   const windowMs = hours * 60 * 60 * 1e3;
   const results = [];
   for (const note of index.notes.values()) {
-    if (note.path === path13) continue;
+    if (note.path === path14) continue;
     const timeDiff = Math.abs(note.modified.getTime() - targetTime);
     if (timeDiff <= windowMs) {
       results.push({
@@ -2188,8 +2448,8 @@ function getActivitySummary(index, days) {
 }
 
 // src/tools/structure.ts
-import * as fs7 from "fs";
-import * as path5 from "path";
+import * as fs8 from "fs";
+import * as path6 from "path";
 var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
 function extractHeadings(content) {
   const lines = content.split("\n");
@@ -2243,10 +2503,10 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path5.join(vaultPath2, notePath);
+  const absolutePath = path6.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs7.promises.readFile(absolutePath, "utf-8");
+    content = await fs8.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -2266,10 +2526,10 @@ async function getNoteStructure(index, notePath, vaultPath2) {
 async function getHeadings(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path5.join(vaultPath2, notePath);
+  const absolutePath = path6.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs7.promises.readFile(absolutePath, "utf-8");
+    content = await fs8.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -2278,10 +2538,10 @@ async function getHeadings(index, notePath, vaultPath2) {
 async function getSectionContent(index, notePath, headingText, vaultPath2, includeSubheadings = true) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path5.join(vaultPath2, notePath);
+  const absolutePath = path6.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs7.promises.readFile(absolutePath, "utf-8");
+    content = await fs8.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -2320,10 +2580,10 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
   const results = [];
   for (const note of index.notes.values()) {
     if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path5.join(vaultPath2, note.path);
+    const absolutePath = path6.join(vaultPath2, note.path);
     let content;
     try {
-      content = await fs7.promises.readFile(absolutePath, "utf-8");
+      content = await fs8.promises.readFile(absolutePath, "utf-8");
     } catch {
       continue;
     }
@@ -2343,8 +2603,8 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
 }
 
 // src/tools/tasks.ts
-import * as fs8 from "fs";
-import * as path6 from "path";
+import * as fs9 from "fs";
+import * as path7 from "path";
 var TASK_REGEX = /^(\s*)- \[([ xX\-])\]\s+(.+)$/;
 var TAG_REGEX2 = /#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
 var DATE_REGEX = /\b(\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4})\b/;
@@ -2370,7 +2630,7 @@ function extractDueDate(text) {
 async function extractTasksFromNote(notePath, absolutePath) {
   let content;
   try {
-    content = await fs8.promises.readFile(absolutePath, "utf-8");
+    content = await fs9.promises.readFile(absolutePath, "utf-8");
   } catch {
     return [];
   }
@@ -2413,7 +2673,7 @@ async function getAllTasks(index, vaultPath2, options = {}) {
   const allTasks = [];
   for (const note of index.notes.values()) {
     if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path6.join(vaultPath2, note.path);
+    const absolutePath = path7.join(vaultPath2, note.path);
     const tasks = await extractTasksFromNote(note.path, absolutePath);
     allTasks.push(...tasks);
   }
@@ -2444,7 +2704,7 @@ async function getAllTasks(index, vaultPath2, options = {}) {
 async function getTasksFromNote(index, notePath, vaultPath2, excludeTags = []) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path6.join(vaultPath2, notePath);
+  const absolutePath = path7.join(vaultPath2, notePath);
   let tasks = await extractTasksFromNote(notePath, absolutePath);
   if (excludeTags.length > 0) {
     tasks = tasks.filter(
@@ -2932,14 +3192,14 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path13, hours, limit: requestedLimit, offset }) => {
+    async ({ path: path14, hours, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
-      const allResults = getContemporaneousNotes(index, path13, hours);
+      const allResults = getContemporaneousNotes(index, path14, hours);
       const result = allResults.slice(offset, offset + limit);
       return {
         content: [{ type: "text", text: JSON.stringify({
-          reference_note: path13,
+          reference_note: path14,
           window_hours: hours,
           total_count: allResults.length,
           returned_count: result.length,
@@ -2977,13 +3237,13 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path13 }) => {
+    async ({ path: path14 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path13, vaultPath2);
+      const result = await getNoteStructure(index, path14, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path13 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path14 }, null, 2) }]
         };
       }
       return {
@@ -3000,18 +3260,18 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path13 }) => {
+    async ({ path: path14 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getHeadings(index, path13, vaultPath2);
+      const result = await getHeadings(index, path14, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path13 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path14 }, null, 2) }]
         };
       }
       return {
         content: [{ type: "text", text: JSON.stringify({
-          path: path13,
+          path: path14,
           heading_count: result.length,
           headings: result
         }, null, 2) }]
@@ -3029,15 +3289,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path13, heading, include_subheadings }) => {
+    async ({ path: path14, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path13, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path14, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path13,
+            path: path14,
             heading
           }, null, 2) }]
         };
@@ -3114,19 +3374,19 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path13 }) => {
+    async ({ path: path14 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config = getConfig();
-      const result = await getTasksFromNote(index, path13, vaultPath2, config.exclude_task_tags || []);
+      const result = await getTasksFromNote(index, path14, vaultPath2, config.exclude_task_tags || []);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path13 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path14 }, null, 2) }]
         };
       }
       return {
         content: [{ type: "text", text: JSON.stringify({
-          path: path13,
+          path: path14,
           task_count: result.length,
           open: result.filter((t) => t.status === "open").length,
           completed: result.filter((t) => t.status === "completed").length,
@@ -3258,14 +3518,14 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path13, limit: requestedLimit, offset }) => {
+    async ({ path: path14, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
-      const allResults = findBidirectionalLinks(index, path13);
+      const allResults = findBidirectionalLinks(index, path14);
       const result = allResults.slice(offset, offset + limit);
       return {
         content: [{ type: "text", text: JSON.stringify({
-          scope: path13 || "all",
+          scope: path14 || "all",
           total_count: allResults.length,
           returned_count: result.length,
           pairs: result
@@ -3672,16 +3932,16 @@ function registerPeriodicTools(server2, getIndex) {
 
 // src/tools/bidirectional.ts
 import { z as z8 } from "zod";
-import * as fs9 from "fs/promises";
-import * as path7 from "path";
+import * as fs10 from "fs/promises";
+import * as path8 from "path";
 import matter2 from "gray-matter";
 var PROSE_PATTERN_REGEX = /^([A-Za-z][A-Za-z0-9 _-]*):\s*(?:\[\[([^\]]+)\]\]|"([^"]+)"|([^\n]+?))\s*$/gm;
 var CODE_BLOCK_REGEX2 = /```[\s\S]*?```|`[^`\n]+`/g;
 var WIKILINK_REGEX2 = /\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]+)?\]\]/g;
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path7.join(vaultPath2, notePath);
+  const fullPath = path8.join(vaultPath2, notePath);
   try {
-    return await fs9.readFile(fullPath, "utf-8");
+    return await fs10.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -4414,21 +4674,21 @@ function registerSchemaTools(server2, getIndex, getVaultPath) {
 
 // src/tools/computed.ts
 import { z as z10 } from "zod";
-import * as fs10 from "fs/promises";
-import * as path8 from "path";
+import * as fs11 from "fs/promises";
+import * as path9 from "path";
 import matter3 from "gray-matter";
 async function readFileContent2(notePath, vaultPath2) {
-  const fullPath = path8.join(vaultPath2, notePath);
+  const fullPath = path9.join(vaultPath2, notePath);
   try {
-    return await fs10.readFile(fullPath, "utf-8");
+    return await fs11.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path8.join(vaultPath2, notePath);
+  const fullPath = path9.join(vaultPath2, notePath);
   try {
-    const stats = await fs10.stat(fullPath);
+    const stats = await fs11.stat(fullPath);
     return {
       modified: stats.mtime,
       created: stats.birthtime
@@ -4584,8 +4844,8 @@ function registerComputedTools(server2, getIndex, getVaultPath) {
 
 // src/tools/migrations.ts
 import { z as z11 } from "zod";
-import * as fs11 from "fs/promises";
-import * as path9 from "path";
+import * as fs12 from "fs/promises";
+import * as path10 from "path";
 import matter4 from "gray-matter";
 function getNotesInFolder2(index, folder) {
   const notes = [];
@@ -4598,17 +4858,17 @@ function getNotesInFolder2(index, folder) {
   return notes;
 }
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path9.join(vaultPath2, notePath);
+  const fullPath = path10.join(vaultPath2, notePath);
   try {
-    return await fs11.readFile(fullPath, "utf-8");
+    return await fs12.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path9.join(vaultPath2, notePath);
+  const fullPath = path10.join(vaultPath2, notePath);
   try {
-    await fs11.writeFile(fullPath, content, "utf-8");
+    await fs12.writeFile(fullPath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -4786,19 +5046,19 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 }
 
 // src/core/vaultRoot.ts
-import * as fs12 from "fs";
-import * as path10 from "path";
+import * as fs13 from "fs";
+import * as path11 from "path";
 var VAULT_MARKERS = [".obsidian", ".claude"];
 function findVaultRoot(startPath) {
-  let current = path10.resolve(startPath || process.cwd());
+  let current = path11.resolve(startPath || process.cwd());
   while (true) {
     for (const marker of VAULT_MARKERS) {
-      const markerPath = path10.join(current, marker);
-      if (fs12.existsSync(markerPath) && fs12.statSync(markerPath).isDirectory()) {
+      const markerPath = path11.join(current, marker);
+      if (fs13.existsSync(markerPath) && fs13.statSync(markerPath).isDirectory()) {
         return current;
       }
     }
-    const parent = path10.dirname(current);
+    const parent = path11.dirname(current);
     if (parent === current) {
       return startPath || process.cwd();
     }
@@ -4810,7 +5070,7 @@ function findVaultRoot(startPath) {
 import chokidar from "chokidar";
 
 // src/core/watch/pathFilter.ts
-import path11 from "path";
+import path12 from "path";
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".git",
   ".obsidian",
@@ -4908,7 +5168,7 @@ function isIgnoredDirectory(segment) {
   return IGNORED_DIRECTORIES.has(segment);
 }
 function hasIgnoredExtension(filePath) {
-  const ext = path11.extname(filePath).toLowerCase();
+  const ext = path12.extname(filePath).toLowerCase();
   return IGNORED_EXTENSIONS.has(ext);
 }
 function matchesIgnoredPattern(filename) {
@@ -4922,7 +5182,7 @@ function normalizePath(filePath) {
   return normalized;
 }
 function getRelativePath(vaultPath2, filePath) {
-  const relative = path11.relative(vaultPath2, filePath);
+  const relative = path12.relative(vaultPath2, filePath);
   return normalizePath(relative);
 }
 function shouldWatch(filePath, vaultPath2) {
@@ -5006,30 +5266,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path13 = normalizePath(rawPath);
+    const path14 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path13,
+      path: path14,
       timestamp: now
     };
-    let pending = this.pending.get(path13);
+    let pending = this.pending.get(path14);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path13, pending);
+      this.pending.set(path14, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path13}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path14}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path13);
+      this.flushPath(path14);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -5050,10 +5310,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path13) {
-    const pending = this.pending.get(path13);
+  flushPath(path14) {
+    const pending = this.pending.get(path14);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path13}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path14}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -5062,7 +5322,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path13,
+        path: path14,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -5070,7 +5330,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path13);
+    this.pending.delete(path14);
   }
   /**
    * Flush all pending events
@@ -5082,7 +5342,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path13, pending] of this.pending) {
+    for (const [path14, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -5090,7 +5350,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path13,
+          path: path14,
           originalEvents: [...pending.events]
         });
       }
@@ -5173,20 +5433,20 @@ function createVaultWatcher(options) {
     ...parseWatcherConfig(),
     ...options.config
   };
-  let state = "starting";
+  let state2 = "starting";
   let lastRebuild = null;
   let error = null;
   let watcher = null;
   let processingBatch = false;
   let pendingBatches = [];
   const getStatus = () => ({
-    state,
+    state: state2,
     pendingEvents: eventQueue?.eventCount || 0,
     lastRebuild,
     error
   });
   const setState = (newState, newError = null) => {
-    state = newState;
+    state2 = newState;
     error = newError;
     onStateChange?.(getStatus());
   };
@@ -5239,31 +5499,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path13) => {
-        console.error(`[flywheel] RAW EVENT: add ${path13}`);
-        if (shouldWatch(path13, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path13}`);
-          eventQueue.push("add", path13);
+      watcher.on("add", (path14) => {
+        console.error(`[flywheel] RAW EVENT: add ${path14}`);
+        if (shouldWatch(path14, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path14}`);
+          eventQueue.push("add", path14);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path13}`);
+          console.error(`[flywheel] FILTERED: add ${path14}`);
         }
       });
-      watcher.on("change", (path13) => {
-        console.error(`[flywheel] RAW EVENT: change ${path13}`);
-        if (shouldWatch(path13, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path13}`);
-          eventQueue.push("change", path13);
+      watcher.on("change", (path14) => {
+        console.error(`[flywheel] RAW EVENT: change ${path14}`);
+        if (shouldWatch(path14, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path14}`);
+          eventQueue.push("change", path14);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path13}`);
+          console.error(`[flywheel] FILTERED: change ${path14}`);
         }
       });
-      watcher.on("unlink", (path13) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path13}`);
-        if (shouldWatch(path13, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path13}`);
-          eventQueue.push("unlink", path13);
+      watcher.on("unlink", (path14) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path14}`);
+        if (shouldWatch(path14, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path14}`);
+          eventQueue.push("unlink", path14);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path13}`);
+          console.error(`[flywheel] FILTERED: unlink ${path14}`);
         }
       });
       watcher.on("ready", () => {
@@ -5295,8 +5555,8 @@ function createVaultWatcher(options) {
 }
 
 // src/core/hubExport.ts
-import fs13 from "fs/promises";
-import path12 from "path";
+import fs14 from "fs/promises";
+import path13 from "path";
 function computeHubScores(index) {
   const hubScores = /* @__PURE__ */ new Map();
   for (const note of index.notes.values()) {
@@ -5351,16 +5611,16 @@ function enrichEntityIndex(index, hubScores) {
   return enriched;
 }
 async function exportHubScores(vaultPath2, vaultIndex2) {
-  const cachePath = path12.join(vaultPath2, ".claude", "wikilink-entities.json");
+  const cachePath = path13.join(vaultPath2, ".claude", "wikilink-entities.json");
   try {
-    await fs13.access(cachePath);
+    await fs14.access(cachePath);
   } catch {
     console.error("[Flywheel] Entity cache not found, skipping hub score export");
     return -1;
   }
   let entityIndex;
   try {
-    const content = await fs13.readFile(cachePath, "utf-8");
+    const content = await fs14.readFile(cachePath, "utf-8");
     entityIndex = JSON.parse(content);
   } catch (e) {
     console.error("[Flywheel] Failed to load entity cache:", e);
@@ -5388,7 +5648,7 @@ async function exportHubScores(vaultPath2, vaultIndex2) {
     }
   }
   try {
-    await fs13.writeFile(cachePath, JSON.stringify(enriched, null, 2), "utf-8");
+    await fs14.writeFile(cachePath, JSON.stringify(enriched, null, 2), "utf-8");
     console.error(`[Flywheel] Exported hub scores: ${hubCount} entities with backlinks`);
     return hubCount;
   } catch (e) {
@@ -5567,8 +5827,8 @@ async function main() {
           }
         });
         let rebuildTimer;
-        legacyWatcher.on("all", (event, path13) => {
-          if (!path13.endsWith(".md")) return;
+        legacyWatcher.on("all", (event, path14) => {
+          if (!path14.endsWith(".md")) return;
           clearTimeout(rebuildTimer);
           rebuildTimer = setTimeout(() => {
             console.error("[flywheel] Rebuilding index (file changed)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-mcp",
-  "version": "1.27.19",
+  "version": "1.27.20",
   "description": "Graph intelligence for markdown vaults. MCP server for Obsidian.",
   "type": "module",
   "main": "dist/index.js",
@@ -24,11 +24,13 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
+    "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",
     "zod": "^3.22.4"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
     "@types/node": "^20.0.0",
     "@vitest/coverage-v8": "^2.0.0",
     "esbuild": "^0.24.0",