flywheel-mcp 1.23.1

package/dist/index.js

@@ -0,0 +1,4893 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/core/vault.ts
+import * as fs from "fs";
+import * as path from "path";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  ".obsidian",
+  ".trash",
+  ".git",
+  "node_modules"
+]);
+var WINDOWS_MAX_PATH = 260;
+var EMOJI_REGEX = /[\u{1F600}-\u{1F64F}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}\u{1F700}-\u{1F77F}\u{1F780}-\u{1F7FF}\u{1F800}-\u{1F8FF}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{FE00}-\u{FE0F}\u{1F1E0}-\u{1F1FF}]/u;
+function isValidPath(fullPath, fileName) {
+  if (EMOJI_REGEX.test(fileName)) {
+    return { valid: false, reason: "contains emoji characters" };
+  }
+  if (fullPath.length >= WINDOWS_MAX_PATH) {
+    return { valid: false, reason: `path length ${fullPath.length} exceeds Windows limit of ${WINDOWS_MAX_PATH}` };
+  }
+  return { valid: true };
+}
+async function scanVault(vaultPath2) {
+  const files = [];
+  async function scan(dir, relativePath = "") {
+    let entries;
+    try {
+      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    } catch (err) {
+      console.error(`Warning: Could not read directory ${dir}:`, err);
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        if (EXCLUDED_DIRS.has(entry.name)) {
+          continue;
+        }
+        try {
+          await scan(fullPath, relPath);
+        } catch (err) {
+          console.error(`Warning: Could not scan directory ${fullPath}:`, err);
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const validation = isValidPath(fullPath, entry.name);
+        if (!validation.valid) {
+          console.warn(`Skipping ${relPath}: ${validation.reason}`);
+          continue;
+        }
+        try {
+          const stats = await fs.promises.stat(fullPath);
+          files.push({
+            path: relPath.replace(/\\/g, "/"),
+            // Normalize to forward slashes
+            absolutePath: fullPath,
+            modified: stats.mtime,
+            created: stats.birthtime
+          });
+        } catch (err) {
+          console.error(`Warning: Could not stat ${fullPath}:`, err);
+        }
+      }
+    }
+  }
+  await scan(vaultPath2);
+  return files;
+}
+
+// src/core/parser.ts
+import * as fs2 from "fs";
+import matter from "gray-matter";
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+function isBinaryContent(content) {
+  const nullBytes = (content.match(/\x00/g) || []).length;
+  if (nullBytes > 0) return true;
+  const sample = content.slice(0, 1e3);
+  const nonPrintable = sample.replace(/[\x20-\x7E\t\n\r]/g, "").length;
+  return nonPrintable / sample.length > 0.1;
+}
+var WIKILINK_REGEX = /\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|([^\]]+))?\]\]/g;
+var TAG_REGEX = /(?:^|\s)#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
+var CODE_BLOCK_REGEX = /```[\s\S]*?```|`[^`\n]+`/g;
+function extractWikilinks(content) {
+  const links = [];
+  const contentWithoutCode = content.replace(CODE_BLOCK_REGEX, (match) => " ".repeat(match.length));
+  const lines = contentWithoutCode.split("\n");
+  let charIndex = 0;
+  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+    let match;
+    WIKILINK_REGEX.lastIndex = 0;
+    while ((match = WIKILINK_REGEX.exec(line)) !== null) {
+      const target = match[1].trim();
+      const alias = match[2]?.trim();
+      if (target) {
+        links.push({
+          target,
+          alias,
+          line: lineNum + 1
+          // 1-indexed
+        });
+      }
+    }
+    charIndex += line.length + 1;
+  }
+  return links;
+}
+function extractTags(content, frontmatter) {
+  const tags = /* @__PURE__ */ new Set();
+  const fmTags = frontmatter.tags;
+  if (Array.isArray(fmTags)) {
+    for (const tag of fmTags) {
+      if (typeof tag === "string") {
+        tags.add(tag.replace(/^#/, ""));
+      }
+    }
+  } else if (typeof fmTags === "string") {
+    tags.add(fmTags.replace(/^#/, ""));
+  }
+  const contentWithoutCode = content.replace(CODE_BLOCK_REGEX, "");
+  let match;
+  TAG_REGEX.lastIndex = 0;
+  while ((match = TAG_REGEX.exec(contentWithoutCode)) !== null) {
+    tags.add(match[1]);
+  }
+  return Array.from(tags);
+}
+function extractAliases(frontmatter) {
+  const aliases = frontmatter.aliases;
+  if (Array.isArray(aliases)) {
+    return aliases.filter((a) => typeof a === "string");
+  }
+  if (typeof aliases === "string") {
+    return [aliases];
+  }
+  return [];
+}
+async function parseNote(file) {
+  const result = await parseNoteWithWarnings(file);
+  if (result.skipped) {
+    throw new Error(result.skipReason || "File skipped");
+  }
+  if (result.warnings.length > 0) {
+    for (const warning of result.warnings) {
+      console.error(`Warning [${file.path}]: ${warning}`);
+    }
+  }
+  return result.note;
+}
+async function parseNoteWithWarnings(file) {
+  const warnings = [];
+  try {
+    const stats = await fs2.promises.stat(file.absolutePath);
+    if (stats.size > MAX_FILE_SIZE) {
+      return {
+        note: createEmptyNote(file),
+        warnings: [],
+        skipped: true,
+        skipReason: `File too large (${(stats.size / 1024 / 1024).toFixed(1)}MB > ${MAX_FILE_SIZE / 1024 / 1024}MB limit)`
+      };
+    }
+  } catch {
+  }
+  let content;
+  try {
+    content = await fs2.promises.readFile(file.absolutePath, "utf-8");
+  } catch (err) {
+    return {
+      note: createEmptyNote(file),
+      warnings: [],
+      skipped: true,
+      skipReason: `Could not read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (content.trim().length === 0) {
+    return {
+      note: createEmptyNote(file),
+      warnings: ["Empty file"],
+      skipped: false
+    };
+  }
+  if (isBinaryContent(content)) {
+    return {
+      note: createEmptyNote(file),
+      warnings: [],
+      skipped: true,
+      skipReason: "Binary content detected"
+    };
+  }
+  let frontmatter = {};
+  let markdown = content;
+  try {
+    const parsed = matter(content);
+    frontmatter = parsed.data;
+    markdown = parsed.content;
+  } catch (err) {
+    warnings.push(`Malformed frontmatter: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
+  return {
+    note: {
+      path: file.path,
+      title,
+      aliases: extractAliases(frontmatter),
+      frontmatter,
+      outlinks: extractWikilinks(markdown),
+      tags: extractTags(markdown, frontmatter),
+      modified: file.modified,
+      created: file.created
+    },
+    warnings,
+    skipped: false
+  };
+}
+function createEmptyNote(file) {
+  const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
+  return {
+    path: file.path,
+    title,
+    aliases: [],
+    frontmatter: {},
+    outlinks: [],
+    tags: [],
+    modified: file.modified,
+    created: file.created
+  };
+}
+
+// src/core/graph.ts
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+var PARSE_CONCURRENCY = 50;
+var PROGRESS_INTERVAL = 100;
+var indexState = "building";
+var indexProgress = { parsed: 0, total: 0 };
+var indexError = null;
+function getIndexState() {
+  return indexState;
+}
+function getIndexProgress() {
+  return { ...indexProgress };
+}
+function getIndexError() {
+  return indexError;
+}
+function setIndexState(state) {
+  indexState = state;
+}
+function setIndexError(error) {
+  indexError = error;
+}
+function updateIndexProgress(parsed, total) {
+  indexProgress = { parsed, total };
+}
+function normalizeTarget(target) {
+  return target.toLowerCase().replace(/\.md$/, "");
+}
+function normalizeNotePath(path11) {
+  return path11.toLowerCase().replace(/\.md$/, "");
+}
+async function buildVaultIndex(vaultPath2, options = {}) {
+  const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
+  console.error(`Scanning vault: ${vaultPath2}`);
+  const startTime = Date.now();
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => {
+      reject(new Error(`Vault indexing timed out after ${timeoutMs / 1e3}s`));
+    }, timeoutMs);
+  });
+  return Promise.race([
+    buildVaultIndexInternal(vaultPath2, startTime, onProgress),
+    timeoutPromise
+  ]);
+}
+async function buildVaultIndexInternal(vaultPath2, startTime, onProgress) {
+  const files = await scanVault(vaultPath2);
+  console.error(`Found ${files.length} markdown files`);
+  updateIndexProgress(0, files.length);
+  const notes = /* @__PURE__ */ new Map();
+  const parseErrors = [];
+  let parsedCount = 0;
+  for (let i = 0; i < files.length; i += PARSE_CONCURRENCY) {
+    const batch = files.slice(i, i + PARSE_CONCURRENCY);
+    const results = await Promise.allSettled(
+      batch.map(async (file) => {
+        const note = await parseNote(file);
+        return { file, note };
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        notes.set(result.value.note.path, result.value.note);
+      } else {
+        const batchIndex = results.indexOf(result);
+        if (batchIndex >= 0 && batch[batchIndex]) {
+          parseErrors.push(batch[batchIndex].path);
+        }
+      }
+      parsedCount++;
+    }
+    updateIndexProgress(parsedCount, files.length);
+    if (parsedCount % PROGRESS_INTERVAL === 0 || parsedCount === files.length) {
+      const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+      console.error(`Parsed ${parsedCount}/${files.length} files (${elapsed}s)`);
+      onProgress?.(parsedCount, files.length);
+    }
+  }
+  if (parseErrors.length > 0) {
+    console.error(`Failed to parse ${parseErrors.length} files`);
+  }
+  const entities = /* @__PURE__ */ new Map();
+  for (const note of notes.values()) {
+    const normalizedTitle = normalizeTarget(note.title);
+    if (!entities.has(normalizedTitle)) {
+      entities.set(normalizedTitle, note.path);
+    }
+    const normalizedPath = normalizeNotePath(note.path);
+    entities.set(normalizedPath, note.path);
+    for (const alias of note.aliases) {
+      const normalizedAlias = normalizeTarget(alias);
+      if (!entities.has(normalizedAlias)) {
+        entities.set(normalizedAlias, note.path);
+      }
+    }
+  }
+  const backlinks = /* @__PURE__ */ new Map();
+  for (const note of notes.values()) {
+    for (const link of note.outlinks) {
+      const normalizedTarget = normalizeTarget(link.target);
+      const targetPath = entities.get(normalizedTarget);
+      const key = targetPath ? normalizeNotePath(targetPath) : normalizedTarget;
+      if (!backlinks.has(key)) {
+        backlinks.set(key, []);
+      }
+      backlinks.get(key).push({
+        source: note.path,
+        line: link.line
+        // Context will be loaded on-demand to save memory
+      });
+    }
+  }
+  const tags = /* @__PURE__ */ new Map();
+  for (const note of notes.values()) {
+    for (const tag of note.tags) {
+      if (!tags.has(tag)) {
+        tags.set(tag, /* @__PURE__ */ new Set());
+      }
+      tags.get(tag).add(note.path);
+    }
+  }
+  console.error(`Index built: ${notes.size} notes, ${entities.size} entities, ${backlinks.size} link targets, ${tags.size} tags`);
+  return {
+    notes,
+    backlinks,
+    entities,
+    tags,
+    builtAt: /* @__PURE__ */ new Date()
+  };
+}
+function resolveTarget(index, target) {
+  const normalized = normalizeTarget(target);
+  return index.entities.get(normalized);
+}
+function getBacklinksForNote(index, notePath) {
+  const normalized = normalizeNotePath(notePath);
+  return index.backlinks.get(normalized) || [];
+}
+function getForwardLinksForNote(index, notePath) {
+  const note = index.notes.get(notePath);
+  if (!note) return [];
+  return note.outlinks.map((link) => {
+    const resolvedPath = resolveTarget(index, link.target);
+    return {
+      target: link.target,
+      alias: link.alias,
+      line: link.line,
+      resolvedPath,
+      exists: resolvedPath !== void 0
+    };
+  });
+}
+function findOrphanNotes(index, folder) {
+  const orphans = [];
+  for (const note of index.notes.values()) {
+    if (folder && !note.path.startsWith(folder)) {
+      continue;
+    }
+    const backlinks = getBacklinksForNote(index, note.path);
+    if (backlinks.length === 0) {
+      orphans.push({
+        path: note.path,
+        title: note.title,
+        modified: note.modified
+      });
+    }
+  }
+  return orphans.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+}
+function findHubNotes(index, minLinks = 5) {
+  const hubs = [];
+  for (const note of index.notes.values()) {
+    const backlinkCount = getBacklinksForNote(index, note.path).length;
+    const forwardLinkCount = note.outlinks.length;
+    const totalConnections = backlinkCount + forwardLinkCount;
+    if (totalConnections >= minLinks) {
+      hubs.push({
+        path: note.path,
+        title: note.title,
+        backlink_count: backlinkCount,
+        forward_link_count: forwardLinkCount,
+        total_connections: totalConnections
+      });
+    }
+  }
+  return hubs.sort((a, b) => b.total_connections - a.total_connections);
+}
+function levenshteinDistance(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function findSimilarEntity(index, target) {
+  const normalized = normalizeTarget(target);
+  const normalizedLen = normalized.length;
+  if (normalizedLen <= 3) {
+    return void 0;
+  }
+  const maxDist = normalizedLen <= 10 ? 1 : 2;
+  let bestMatch;
+  for (const [entity, path11] of index.entities) {
+    const lenDiff = Math.abs(entity.length - normalizedLen);
+    if (lenDiff > maxDist) {
+      continue;
+    }
+    const dist = levenshteinDistance(normalized, entity);
+    if (dist > 0 && dist <= maxDist) {
+      if (!bestMatch || dist < bestMatch.distance) {
+        bestMatch = { path: path11, entity, distance: dist };
+        if (dist === 1) {
+          return bestMatch;
+        }
+      }
+    }
+  }
+  return bestMatch;
+}
+
+// src/tools/graph.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+import { z } from "zod";
+
+// src/core/constants.ts
+var MAX_LIMIT = 200;
+
+// src/core/indexGuard.ts
+function requireIndex() {
+  const state = getIndexState();
+  if (state === "building") {
+    const { parsed, total } = getIndexProgress();
+    const progress = total > 0 ? ` (${parsed}/${total} files)` : "";
+    throw new Error(`Index building${progress}... try again shortly`);
+  }
+  if (state === "error") {
+    const error = getIndexError();
+    throw new Error(`Index failed to build: ${error?.message || "unknown error"}`);
+  }
+}
+
+// src/tools/graph.ts
+async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
+  try {
+    const fullPath = path2.join(vaultPath2, sourcePath);
+    const content = await fs3.promises.readFile(fullPath, "utf-8");
+    const lines = content.split("\n");
+    const startLine = Math.max(0, line - 1 - contextLines);
+    const endLine = Math.min(lines.length, line + contextLines);
+    return lines.slice(startLine, endLine).join("\n").trim();
+  } catch {
+    return "";
+  }
+}
+var BacklinkItemSchema = z.object({
+  source: z.string().describe("Path of the note containing the link"),
+  line: z.number().describe("Line number where the link appears"),
+  context: z.string().optional().describe("Surrounding text for context")
+});
+var GetBacklinksOutputSchema = {
+  note: z.string().describe("The resolved note path"),
+  backlink_count: z.number().describe("Total number of backlinks found"),
+  returned_count: z.number().describe("Number of backlinks returned (may be limited)"),
+  backlinks: z.array(BacklinkItemSchema).describe("List of backlinks")
+};
+function registerGraphTools(server2, getIndex, getVaultPath) {
+  server2.registerTool(
+    "get_backlinks",
+    {
+      title: "Get Backlinks",
+      description: "Get all notes that link TO the specified note. Returns the source file paths and line numbers where links appear.",
+      inputSchema: {
+        path: z.string().describe('Path to the note (e.g., "daily/2024-01-15.md" or just "My Note")'),
+        include_context: z.boolean().default(true).describe("Include surrounding text for context"),
+        limit: z.number().default(50).describe("Maximum number of results to return"),
+        offset: z.number().default(0).describe("Number of results to skip (for pagination)")
+      },
+      outputSchema: GetBacklinksOutputSchema
+    },
+    async ({ path: notePath, include_context, limit: requestedLimit, offset }) => {
+      requireIndex();
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      let resolvedPath = notePath;
+      if (!notePath.endsWith(".md")) {
+        const resolved = resolveTarget(index, notePath);
+        if (resolved) {
+          resolvedPath = resolved;
+        } else {
+          resolvedPath = notePath + ".md";
+        }
+      }
+      const allBacklinks = getBacklinksForNote(index, resolvedPath);
+      const backlinks = allBacklinks.slice(offset, offset + limit);
+      const results = await Promise.all(
+        backlinks.map(async (bl) => {
+          const result = {
+            source: bl.source,
+            line: bl.line
+          };
+          if (include_context) {
+            result.context = await getContext(vaultPath2, bl.source, bl.line);
+          }
+          return result;
+        })
+      );
+      const output = {
+        note: resolvedPath,
+        backlink_count: allBacklinks.length,
+        returned_count: results.length,
+        backlinks: results
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const ForwardLinkItemSchema = z.object({
+    target: z.string().describe("The link target as written"),
+    alias: z.string().optional().describe("Display text if using [[target|alias]] syntax"),
+    line: z.number().describe("Line number where the link appears"),
+    resolved_path: z.string().optional().describe("Resolved path if target exists"),
+    exists: z.boolean().describe("Whether the target note exists")
+  });
+  const GetForwardLinksOutputSchema = {
+    note: z.string().describe("The source note path"),
+    forward_link_count: z.number().describe("Total number of forward links"),
+    forward_links: z.array(ForwardLinkItemSchema).describe("List of forward links")
+  };
+  server2.registerTool(
+    "get_forward_links",
+    {
+      title: "Get Forward Links",
+      description: "Get all notes that this note links TO. Returns the target paths and whether they exist.",
+      inputSchema: {
+        path: z.string().describe('Path to the note (e.g., "daily/2024-01-15.md" or just "My Note")')
+      },
+      outputSchema: GetForwardLinksOutputSchema
+    },
+    async ({ path: notePath }) => {
+      requireIndex();
+      const index = getIndex();
+      let resolvedPath = notePath;
+      if (!notePath.endsWith(".md")) {
+        const resolved = resolveTarget(index, notePath);
+        if (resolved) {
+          resolvedPath = resolved;
+        } else {
+          resolvedPath = notePath + ".md";
+        }
+      }
+      const forwardLinks = getForwardLinksForNote(index, resolvedPath);
+      const output = {
+        note: resolvedPath,
+        forward_link_count: forwardLinks.length,
+        forward_links: forwardLinks.map((link) => ({
+          target: link.target,
+          alias: link.alias,
+          line: link.line,
+          resolved_path: link.resolvedPath,
+          exists: link.exists
+        }))
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const OrphanNoteSchema = z.object({
+    path: z.string().describe("Path to the orphan note"),
+    title: z.string().describe("Title of the note"),
+    modified: z.string().describe("Last modified date (ISO format)")
+  });
+  const FindOrphansOutputSchema = {
+    orphan_count: z.number().describe("Total number of orphan notes found"),
+    returned_count: z.number().describe("Number of orphans returned (may be limited)"),
+    folder: z.string().optional().describe("Folder filter if specified"),
+    orphans: z.array(OrphanNoteSchema).describe("List of orphan notes")
+  };
+  server2.registerTool(
+    "find_orphan_notes",
+    {
+      title: "Find Orphan Notes",
+      description: "Find notes that have no backlinks (no other notes link to them). Useful for finding disconnected content.",
+      inputSchema: {
+        folder: z.string().optional().describe('Limit search to a specific folder (e.g., "daily-notes/")'),
+        limit: z.number().default(50).describe("Maximum number of results to return"),
+        offset: z.number().default(0).describe("Number of results to skip (for pagination)")
+      },
+      outputSchema: FindOrphansOutputSchema
+    },
+    async ({ folder, limit: requestedLimit, offset }) => {
+      requireIndex();
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allOrphans = findOrphanNotes(index, folder);
+      const orphans = allOrphans.slice(offset, offset + limit);
+      const output = {
+        orphan_count: allOrphans.length,
+        returned_count: orphans.length,
+        folder,
+        orphans: orphans.map((o) => ({
+          path: o.path,
+          title: o.title,
+          modified: o.modified.toISOString()
+        }))
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const HubNoteSchema = z.object({
+    path: z.string().describe("Path to the hub note"),
+    title: z.string().describe("Title of the note"),
+    backlink_count: z.number().describe("Number of notes linking TO this note"),
+    forward_link_count: z.number().describe("Number of notes this note links TO"),
+    total_connections: z.number().describe("Total connections (backlinks + forward links)")
+  });
+  const FindHubsOutputSchema = {
+    hub_count: z.number().describe("Total number of hub notes found"),
+    returned_count: z.number().describe("Number of hubs returned (may be limited)"),
+    min_links: z.number().describe("Minimum connection threshold used"),
+    hubs: z.array(HubNoteSchema).describe("List of hub notes, sorted by total connections")
+  };
+  server2.registerTool(
+    "find_hub_notes",
+    {
+      title: "Find Hub Notes",
+      description: "Find highly connected notes (hubs) that have many links to/from other notes. Useful for identifying key concepts.",
+      inputSchema: {
+        min_links: z.number().default(5).describe("Minimum total connections (backlinks + forward links) to qualify as a hub"),
+        limit: z.number().default(50).describe("Maximum number of results to return"),
+        offset: z.number().default(0).describe("Number of results to skip (for pagination)")
+      },
+      outputSchema: FindHubsOutputSchema
+    },
+    async ({ min_links, limit: requestedLimit, offset }) => {
+      requireIndex();
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allHubs = findHubNotes(index, min_links);
+      const hubs = allHubs.slice(offset, offset + limit);
+      const output = {
+        hub_count: allHubs.length,
+        returned_count: hubs.length,
+        min_links,
+        hubs: hubs.map((h) => ({
+          path: h.path,
+          title: h.title,
+          backlink_count: h.backlink_count,
+          forward_link_count: h.forward_link_count,
+          total_connections: h.total_connections
+        }))
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+}
+
+// src/tools/wikilinks.ts
+import { z as z2 } from "zod";
+function findEntityMatches(text, entities) {
+  const matches = [];
+  const sortedEntities = Array.from(entities.entries()).filter(([name]) => name.length >= 2).sort((a, b) => b[0].length - a[0].length);
+  const skipRegions = [];
+  const wikilinkRegex = /\[\[[^\]]+\]\]/g;
+  let match;
+  while ((match = wikilinkRegex.exec(text)) !== null) {
+    skipRegions.push({ start: match.index, end: match.index + match[0].length });
+  }
+  const codeBlockRegex = /```[\s\S]*?```|`[^`\n]+`/g;
+  while ((match = codeBlockRegex.exec(text)) !== null) {
+    skipRegions.push({ start: match.index, end: match.index + match[0].length });
+  }
+  const urlRegex = /https?:\/\/[^\s)>\]]+/g;
+  while ((match = urlRegex.exec(text)) !== null) {
+    skipRegions.push({ start: match.index, end: match.index + match[0].length });
+  }
+  const matchedPositions = /* @__PURE__ */ new Set();
+  function shouldSkip(start, end) {
+    for (const region of skipRegions) {
+      if (start < region.end && end > region.start) {
+        return true;
+      }
+    }
+    for (let i = start; i < end; i++) {
+      if (matchedPositions.has(i)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function markMatched(start, end) {
+    for (let i = start; i < end; i++) {
+      matchedPositions.add(i);
+    }
+  }
+  const textLower = text.toLowerCase();
+  for (const [entityName, targetPath] of sortedEntities) {
+    const entityLower = entityName.toLowerCase();
+    let searchStart = 0;
+    while (searchStart < textLower.length) {
+      const pos = textLower.indexOf(entityLower, searchStart);
+      if (pos === -1) break;
+      const end = pos + entityName.length;
+      const charBefore = pos > 0 ? text[pos - 1] : " ";
+      const charAfter = end < text.length ? text[end] : " ";
+      const isWordBoundaryBefore = /[\s\n\r.,;:!?()[\]{}'"<>-]/.test(charBefore);
+      const isWordBoundaryAfter = /[\s\n\r.,;:!?()[\]{}'"<>-]/.test(charAfter);
+      if (isWordBoundaryBefore && isWordBoundaryAfter && !shouldSkip(pos, end)) {
+        const originalText = text.substring(pos, end);
+        matches.push({
+          entity: originalText,
+          start: pos,
+          end,
+          target: targetPath
+        });
+        markMatched(pos, end);
+      }
+      searchStart = pos + 1;
+    }
+  }
+  return matches.sort((a, b) => a.start - b.start);
+}
+function registerWikilinkTools(server2, getIndex, getVaultPath) {
+  const SuggestionSchema = z2.object({
+    entity: z2.string().describe("The matched text in the input"),
+    start: z2.number().describe("Start position in text (0-indexed)"),
+    end: z2.number().describe("End position in text (0-indexed)"),
+    target: z2.string().describe("Path to the target note")
+  });
+  const SuggestWikilinksOutputSchema = {
+    input_length: z2.number().describe("Length of the input text"),
+    suggestion_count: z2.number().describe("Total number of suggestions found"),
+    returned_count: z2.number().describe("Number of suggestions returned (may be limited)"),
+    suggestions: z2.array(SuggestionSchema).describe("List of wikilink suggestions")
+  };
+  server2.registerTool(
+    "suggest_wikilinks",
+    {
+      title: "Suggest Wikilinks",
+      description: "Analyze text and suggest where wikilinks could be added. Finds mentions of existing note titles and aliases.",
+      inputSchema: {
+        text: z2.string().describe("The text to analyze for potential wikilinks"),
+        limit: z2.number().default(50).describe("Maximum number of suggestions to return"),
+        offset: z2.number().default(0).describe("Number of suggestions to skip (for pagination)")
+      },
+      outputSchema: SuggestWikilinksOutputSchema
+    },
+    async ({ text, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allMatches = findEntityMatches(text, index.entities);
+      const matches = allMatches.slice(offset, offset + limit);
+      const output = {
+        input_length: text.length,
+        suggestion_count: allMatches.length,
+        returned_count: matches.length,
+        suggestions: matches
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const BrokenLinkSchema = z2.object({
+    source: z2.string().describe("Path to the note containing the broken link"),
+    target: z2.string().describe("The broken link target"),
+    line: z2.number().describe("Line number where the link appears"),
+    suggestion: z2.string().optional().describe("Suggested fix if a similar note exists")
+  });
+  const ValidateLinksOutputSchema = {
+    scope: z2.string().describe('What was validated (note path or "all")'),
+    total_links: z2.number().describe("Total number of links checked"),
+    valid_links: z2.number().describe("Number of valid links"),
+    broken_links: z2.number().describe("Total number of broken links"),
+    returned_count: z2.number().describe("Number of broken links returned (may be limited)"),
+    broken: z2.array(BrokenLinkSchema).describe("List of broken links")
+  };
+  function findSimilarEntity2(target, entities) {
+    const targetLower = target.toLowerCase();
+    for (const [name, path11] of entities) {
+      if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
+        return path11;
+      }
+    }
+    for (const [name, path11] of entities) {
+      if (name.includes(targetLower) || targetLower.includes(name)) {
+        return path11;
+      }
+    }
+    return void 0;
+  }
+  server2.registerTool(
+    "validate_links",
+    {
+      title: "Validate Links",
+      description: "Check wikilinks in a note (or all notes) and report broken links. Optionally suggests fixes.",
+      inputSchema: {
+        path: z2.string().optional().describe("Path to a specific note to validate. If omitted, validates all notes."),
+        limit: z2.number().default(50).describe("Maximum number of broken links to return"),
+        offset: z2.number().default(0).describe("Number of broken links to skip (for pagination)")
+      },
+      outputSchema: ValidateLinksOutputSchema
+    },
+    async ({ path: notePath, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allBroken = [];
+      let totalLinks = 0;
+      let validLinks = 0;
+      let notesToCheck;
+      if (notePath) {
+        let resolvedPath = notePath;
+        if (!notePath.endsWith(".md")) {
+          const resolved = resolveTarget(index, notePath);
+          if (resolved) {
+            resolvedPath = resolved;
+          } else {
+            resolvedPath = notePath + ".md";
+          }
+        }
+        notesToCheck = [resolvedPath];
+      } else {
+        notesToCheck = Array.from(index.notes.keys());
+      }
+      for (const sourcePath of notesToCheck) {
+        const note = index.notes.get(sourcePath);
+        if (!note) continue;
+        for (const link of note.outlinks) {
+          totalLinks++;
+          const resolved = resolveTarget(index, link.target);
+          if (resolved) {
+            validLinks++;
+          } else {
+            const suggestion = findSimilarEntity2(link.target, index.entities);
+            allBroken.push({
+              source: sourcePath,
+              target: link.target,
+              line: link.line,
+              suggestion
+            });
+          }
+        }
+      }
+      const broken = allBroken.slice(offset, offset + limit);
+      const output = {
+        scope: notePath || "all",
+        total_links: totalLinks,
+        valid_links: validLinks,
+        broken_links: allBroken.length,
+        returned_count: broken.length,
+        broken
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+}
+
+// src/tools/health.ts
+import * as fs4 from "fs";
+import { z as z3 } from "zod";
+var STALE_THRESHOLD_SECONDS = 300;
+function registerHealthTools(server2, getIndex, getVaultPath) {
+  const IndexProgressSchema = z3.object({
+    parsed: z3.number().describe("Number of files parsed so far"),
+    total: z3.number().describe("Total number of files to parse")
+  }).optional();
+  const HealthCheckOutputSchema = {
+    status: z3.enum(["healthy", "degraded", "unhealthy"]).describe("Overall health status"),
+    vault_accessible: z3.boolean().describe("Whether the vault path is accessible"),
+    vault_path: z3.string().describe("The vault path being used"),
+    index_state: z3.enum(["building", "ready", "error"]).describe("Current state of the vault index"),
+    index_progress: IndexProgressSchema.describe("Progress of index build (when building)"),
+    index_error: z3.string().optional().describe("Error message if index failed to build"),
+    index_built: z3.boolean().describe("Whether the index has been built"),
+    index_age_seconds: z3.number().describe("Seconds since the index was built"),
+    index_stale: z3.boolean().describe("Whether the index is stale (>5 minutes old)"),
+    note_count: z3.number().describe("Number of notes in the index"),
+    entity_count: z3.number().describe("Number of linkable entities (titles + aliases)"),
+    tag_count: z3.number().describe("Number of unique tags"),
+    recommendations: z3.array(z3.string()).describe("Suggested actions if any issues detected")
+  };
+  server2.registerTool(
+    "health_check",
+    {
+      title: "Health Check",
+      description: "Check MCP server health status. Returns vault accessibility, index freshness, and recommendations. Use at session start to verify MCP is working correctly.",
+      inputSchema: {},
+      outputSchema: HealthCheckOutputSchema
+    },
+    async () => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const recommendations = [];
+      const indexState2 = getIndexState();
+      const indexProgress2 = getIndexProgress();
+      const indexErrorObj = getIndexError();
+      let vaultAccessible = false;
+      try {
+        fs4.accessSync(vaultPath2, fs4.constants.R_OK);
+        vaultAccessible = true;
+      } catch {
+        vaultAccessible = false;
+        recommendations.push("Vault path is not accessible. Check PROJECT_PATH environment variable.");
+      }
+      const indexBuilt = indexState2 === "ready" && index !== void 0 && index.notes !== void 0;
+      const indexAge = indexBuilt && index.builtAt ? Math.floor((Date.now() - index.builtAt.getTime()) / 1e3) : -1;
+      const indexStale = indexBuilt && indexAge > STALE_THRESHOLD_SECONDS;
+      if (indexState2 === "building") {
+        const { parsed, total } = indexProgress2;
+        const progress = total > 0 ? ` (${parsed}/${total} files)` : "";
+        recommendations.push(`Index is building${progress}. Some tools may not be available yet.`);
+      } else if (indexState2 === "error") {
+        recommendations.push(`Index failed to build: ${indexErrorObj?.message || "unknown error"}`);
+      } else if (indexStale) {
+        recommendations.push(`Index is ${Math.floor(indexAge / 60)} minutes old. Consider running refresh_index.`);
+      }
+      const noteCount = indexBuilt ? index.notes.size : 0;
+      const entityCount = indexBuilt ? index.entities.size : 0;
+      const tagCount = indexBuilt ? index.tags.size : 0;
+      if (indexBuilt && noteCount === 0 && vaultAccessible) {
+        recommendations.push("No notes found in vault. Is PROJECT_PATH pointing to a markdown vault?");
+      }
+      let status;
+      if (!vaultAccessible || indexState2 === "error") {
+        status = "unhealthy";
+      } else if (indexState2 === "building" || indexStale || recommendations.length > 0) {
+        status = "degraded";
+      } else {
+        status = "healthy";
+      }
+      const output = {
+        status,
+        vault_accessible: vaultAccessible,
+        vault_path: vaultPath2,
+        index_state: indexState2,
+        index_progress: indexState2 === "building" ? indexProgress2 : void 0,
+        index_error: indexState2 === "error" && indexErrorObj ? indexErrorObj.message : void 0,
+        index_built: indexBuilt,
+        index_age_seconds: indexAge,
+        index_stale: indexStale,
+        note_count: noteCount,
+        entity_count: entityCount,
+        tag_count: tagCount,
+        recommendations
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const BrokenLinkSchema = z3.object({
+    source: z3.string().describe("Path to the note containing the broken link"),
+    target: z3.string().describe("The broken link target"),
+    line: z3.number().describe("Line number where the link appears"),
+    suggestion: z3.string().describe("Suggested correct target (similar entity found)")
+  });
+  const FindBrokenLinksOutputSchema = {
+    scope: z3.string().describe('Folder searched, or "all" for entire vault'),
+    broken_count: z3.number().describe("Total number of broken links found"),
+    returned_count: z3.number().describe("Number of broken links returned (may be limited)"),
+    affected_notes: z3.number().describe("Number of notes with broken links"),
+    broken_links: z3.array(BrokenLinkSchema).describe("List of broken links with suggestions")
+  };
+  server2.registerTool(
+    "find_broken_links",
+    {
+      title: "Find Broken Links",
+      description: "Find wikilinks that appear to be typos or mistakes (links to non-existent notes that have a similar existing note). Links to notes that simply do not exist yet are not considered broken - only links where a similar note exists (suggesting a typo).",
+      inputSchema: {
+        folder: z3.string().optional().describe('Limit search to a specific folder (e.g., "daily-notes/")'),
+        limit: z3.number().default(50).describe("Maximum number of results to return (capped at 500)"),
+        offset: z3.number().default(0).describe("Number of results to skip (for pagination)")
+      },
+      outputSchema: FindBrokenLinksOutputSchema
+    },
+    async ({ folder, limit: requestedLimit, offset }) => {
+      const index = getIndex();
+      const affectedNotes = /* @__PURE__ */ new Set();
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const similarityCache = /* @__PURE__ */ new Map();
+      const unresolvedLinks = [];
+      for (const note of index.notes.values()) {
+        if (folder && !note.path.startsWith(folder)) {
+          continue;
+        }
+        for (const link of note.outlinks) {
+          const resolved = resolveTarget(index, link.target);
+          if (!resolved) {
+            unresolvedLinks.push({
+              source: note.path,
+              target: link.target,
+              line: link.line
+            });
+          }
+        }
+      }
+      unresolvedLinks.sort((a, b) => {
+        const pathCompare = a.source.localeCompare(b.source);
+        if (pathCompare !== 0) return pathCompare;
+        return a.line - b.line;
+      });
+      const allBrokenLinks = [];
+      for (const link of unresolvedLinks) {
+        let similar;
+        if (similarityCache.has(link.target)) {
+          similar = similarityCache.get(link.target);
+        } else {
+          const result = findSimilarEntity(index, link.target);
+          similar = result ?? null;
+          similarityCache.set(link.target, similar);
+        }
+        if (similar) {
+          allBrokenLinks.push({
+            source: link.source,
+            target: link.target,
+            line: link.line,
+            suggestion: similar.path
+          });
+          affectedNotes.add(link.source);
+        }
+      }
+      const brokenLinks = allBrokenLinks.slice(offset, offset + limit);
+      const output = {
+        scope: folder || "all",
+        broken_count: allBrokenLinks.length,
+        returned_count: brokenLinks.length,
+        affected_notes: affectedNotes.size,
+        broken_links: brokenLinks
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const TagStatSchema = z3.object({
+    tag: z3.string().describe("The tag name"),
+    count: z3.number().describe("Number of notes with this tag")
+  });
+  const FolderStatSchema = z3.object({
+    folder: z3.string().describe("Folder path"),
+    note_count: z3.number().describe("Number of notes in this folder")
+  });
+  const OrphanStatsSchema = z3.object({
+    total: z3.number().describe("Total orphan notes (no backlinks)"),
+    periodic: z3.number().describe("Orphan periodic notes (daily/weekly/monthly - expected)"),
+    content: z3.number().describe("Orphan content notes (non-periodic - may need linking)")
+  });
+  const GetVaultStatsOutputSchema = {
+    total_notes: z3.number().describe("Total number of notes in the vault"),
+    total_links: z3.number().describe("Total number of wikilinks"),
+    total_tags: z3.number().describe("Total number of unique tags"),
+    orphan_notes: OrphanStatsSchema.describe("Orphan notes breakdown"),
+    broken_links: z3.number().describe("Links pointing to non-existent notes"),
+    average_links_per_note: z3.number().describe("Average outgoing links per note"),
+    most_linked_notes: z3.array(
+      z3.object({
+        path: z3.string(),
+        backlinks: z3.number()
+      })
+    ).describe("Top 10 most linked-to notes"),
+    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() || "";
+    const nameWithoutExt = filename.replace(/\.md$/, "");
+    const patterns = [
+      /^\d{4}-\d{2}-\d{2}$/,
+      // YYYY-MM-DD (daily)
+      /^\d{4}-W\d{2}$/,
+      // YYYY-Wnn (weekly)
+      /^\d{4}-\d{2}$/,
+      // YYYY-MM (monthly)
+      /^\d{4}-Q[1-4]$/,
+      // YYYY-Qn (quarterly)
+      /^\d{4}$/
+      // YYYY (yearly)
+    ];
+    const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
+    const folder = path11.split("/")[0]?.toLowerCase() || "";
+    return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
+  }
+  server2.registerTool(
+    "get_vault_stats",
+    {
+      title: "Get Vault Statistics",
+      description: "Get comprehensive statistics about the vault: note counts, link metrics, tag usage, and folder distribution.",
+      inputSchema: {},
+      outputSchema: GetVaultStatsOutputSchema
+    },
+    async () => {
+      const index = getIndex();
+      const totalNotes = index.notes.size;
+      let totalLinks = 0;
+      let brokenLinks = 0;
+      let orphanTotal = 0;
+      let orphanPeriodic = 0;
+      let orphanContent = 0;
+      for (const note of index.notes.values()) {
+        totalLinks += note.outlinks.length;
+        for (const link of note.outlinks) {
+          if (!resolveTarget(index, link.target)) {
+            const similar = findSimilarEntity(index, link.target);
+            if (similar) {
+              brokenLinks++;
+            }
+          }
+        }
+      }
+      for (const note of index.notes.values()) {
+        const backlinks = getBacklinksForNote(index, note.path);
+        if (backlinks.length === 0) {
+          orphanTotal++;
+          if (isPeriodicNote(note.path)) {
+            orphanPeriodic++;
+          } else {
+            orphanContent++;
+          }
+        }
+      }
+      const linkCounts = [];
+      for (const note of index.notes.values()) {
+        const backlinks = getBacklinksForNote(index, note.path);
+        if (backlinks.length > 0) {
+          linkCounts.push({ path: note.path, backlinks: backlinks.length });
+        }
+      }
+      linkCounts.sort((a, b) => b.backlinks - a.backlinks);
+      const mostLinkedNotes = linkCounts.slice(0, 10);
+      const tagStats = [];
+      for (const [tag, notes] of index.tags) {
+        tagStats.push({ tag, count: notes.size });
+      }
+      tagStats.sort((a, b) => b.count - a.count);
+      const topTags = tagStats.slice(0, 20);
+      const folderCounts = /* @__PURE__ */ new Map();
+      for (const note of index.notes.values()) {
+        const parts = note.path.split("/");
+        const folder = parts.length > 1 ? parts[0] : "(root)";
+        folderCounts.set(folder, (folderCounts.get(folder) || 0) + 1);
+      }
+      const folders = Array.from(folderCounts.entries()).map(([folder, count]) => ({ folder, note_count: count })).sort((a, b) => b.note_count - a.note_count);
+      const output = {
+        total_notes: totalNotes,
+        total_links: totalLinks,
+        total_tags: index.tags.size,
+        orphan_notes: {
+          total: orphanTotal,
+          periodic: orphanPeriodic,
+          content: orphanContent
+        },
+        broken_links: brokenLinks,
+        average_links_per_note: totalNotes > 0 ? Math.round(totalLinks / totalNotes * 100) / 100 : 0,
+        most_linked_notes: mostLinkedNotes,
+        top_tags: topTags,
+        folders
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+}
+
+// src/tools/query.ts
+import { z as z4 } from "zod";
+function matchesFrontmatter(note, where) {
+  for (const [key, value] of Object.entries(where)) {
+    const noteValue = note.frontmatter[key];
+    if (value === null || value === void 0) {
+      if (noteValue !== null && noteValue !== void 0) {
+        return false;
+      }
+      continue;
+    }
+    if (Array.isArray(noteValue)) {
+      if (!noteValue.some((v) => String(v).toLowerCase() === String(value).toLowerCase())) {
+        return false;
+      }
+      continue;
+    }
+    if (typeof value === "string" && typeof noteValue === "string") {
+      if (noteValue.toLowerCase() !== value.toLowerCase()) {
+        return false;
+      }
+      continue;
+    }
+    if (noteValue !== value) {
+      return false;
+    }
+  }
+  return true;
+}
+function hasTag(note, tag) {
+  const normalizedTag = tag.replace(/^#/, "").toLowerCase();
+  return note.tags.some((t) => t.toLowerCase() === normalizedTag);
+}
+function hasAnyTag(note, tags) {
+  return tags.some((tag) => hasTag(note, tag));
+}
+function hasAllTags(note, tags) {
+  return tags.every((tag) => hasTag(note, tag));
+}
+function inFolder(note, folder) {
+  const normalizedFolder = folder.endsWith("/") ? folder : folder + "/";
+  return note.path.startsWith(normalizedFolder) || note.path.split("/")[0] === folder.replace("/", "");
+}
+function sortNotes(notes, sortBy, order) {
+  const sorted = [...notes];
+  sorted.sort((a, b) => {
+    let comparison = 0;
+    switch (sortBy) {
+      case "modified":
+        comparison = a.modified.getTime() - b.modified.getTime();
+        break;
+      case "created":
+        const aCreated = a.created || a.modified;
+        const bCreated = b.created || b.modified;
+        comparison = aCreated.getTime() - bCreated.getTime();
+        break;
+      case "title":
+        comparison = a.title.localeCompare(b.title);
+        break;
+    }
+    return order === "desc" ? -comparison : comparison;
+  });
+  return sorted;
+}
+function registerQueryTools(server2, getIndex, getVaultPath) {
+  const NoteResultSchema = z4.object({
+    path: z4.string().describe("Path to the note"),
+    title: z4.string().describe("Note title"),
+    modified: z4.string().describe("Last modified date (ISO format)"),
+    created: z4.string().optional().describe("Creation date if available (ISO format)"),
+    tags: z4.array(z4.string()).describe("Tags on this note"),
+    frontmatter: z4.record(z4.unknown()).describe("Frontmatter fields")
+  });
+  const SearchNotesOutputSchema = {
+    query: z4.object({
+      where: z4.record(z4.unknown()).optional(),
+      has_tag: z4.string().optional(),
+      has_any_tag: z4.array(z4.string()).optional(),
+      has_all_tags: z4.array(z4.string()).optional(),
+      folder: z4.string().optional(),
+      title_contains: z4.string().optional(),
+      sort_by: z4.string().optional(),
+      order: z4.string().optional(),
+      limit: z4.number().optional()
+    }).describe("The search query that was executed"),
+    total_matches: z4.number().describe("Total number of matching notes"),
+    returned: z4.number().describe("Number of notes returned (may be limited)"),
+    notes: z4.array(NoteResultSchema).describe("Matching notes")
+  };
+  server2.registerTool(
+    "search_notes",
+    {
+      title: "Search Notes",
+      description: "Search notes by frontmatter fields, tags, folders, or title. Covers ~80% of Dataview use cases.",
+      inputSchema: {
+        where: z4.record(z4.unknown()).optional().describe('Frontmatter filters as key-value pairs. Example: { "type": "project", "status": "active" }'),
+        has_tag: z4.string().optional().describe('Filter to notes with this tag. Example: "work"'),
+        has_any_tag: z4.array(z4.string()).optional().describe('Filter to notes with any of these tags. Example: ["work", "personal"]'),
+        has_all_tags: z4.array(z4.string()).optional().describe('Filter to notes with all of these tags. Example: ["project", "active"]'),
+        folder: z4.string().optional().describe('Limit to notes in this folder. Example: "daily-notes"'),
+        title_contains: z4.string().optional().describe("Filter to notes whose title contains this text (case-insensitive)"),
+        sort_by: z4.enum(["modified", "created", "title"]).default("modified").describe("Field to sort by"),
+        order: z4.enum(["asc", "desc"]).default("desc").describe("Sort order"),
+        limit: z4.number().default(50).describe("Maximum number of results to return")
+      },
+      outputSchema: SearchNotesOutputSchema
+    },
+    async ({
+      where,
+      has_tag,
+      has_any_tag,
+      has_all_tags,
+      folder,
+      title_contains,
+      sort_by = "modified",
+      order = "desc",
+      limit: requestedLimit = 50
+    }) => {
+      const index = getIndex();
+      const limit = Math.min(requestedLimit, MAX_LIMIT);
+      let matchingNotes = Array.from(index.notes.values());
+      if (where && Object.keys(where).length > 0) {
+        matchingNotes = matchingNotes.filter((note) => matchesFrontmatter(note, where));
+      }
+      if (has_tag) {
+        matchingNotes = matchingNotes.filter((note) => hasTag(note, has_tag));
+      }
+      if (has_any_tag && has_any_tag.length > 0) {
+        matchingNotes = matchingNotes.filter((note) => hasAnyTag(note, has_any_tag));
+      }
+      if (has_all_tags && has_all_tags.length > 0) {
+        matchingNotes = matchingNotes.filter((note) => hasAllTags(note, has_all_tags));
+      }
+      if (folder) {
+        matchingNotes = matchingNotes.filter((note) => inFolder(note, folder));
+      }
+      if (title_contains) {
+        const searchTerm = title_contains.toLowerCase();
+        matchingNotes = matchingNotes.filter(
+          (note) => note.title.toLowerCase().includes(searchTerm)
+        );
+      }
+      matchingNotes = sortNotes(matchingNotes, sort_by, order);
+      const totalMatches = matchingNotes.length;
+      const limitedNotes = matchingNotes.slice(0, limit);
+      const notes = limitedNotes.map((note) => ({
+        path: note.path,
+        title: note.title,
+        modified: note.modified.toISOString(),
+        created: note.created?.toISOString(),
+        tags: note.tags,
+        frontmatter: note.frontmatter
+      }));
+      const output = {
+        query: {
+          where,
+          has_tag,
+          has_any_tag,
+          has_all_tags,
+          folder,
+          title_contains,
+          sort_by,
+          order,
+          limit
+        },
+        total_matches: totalMatches,
+        returned: notes.length,
+        notes
+      };
+      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 { z as z5 } from "zod";
+
+// src/core/config.ts
+import * as fs5 from "fs";
+import * as path3 from "path";
+var DEFAULT_CONFIG = {
+  exclude_task_tags: []
+};
+function loadConfig(vaultPath2) {
+  const claudeDir = path3.join(vaultPath2, ".claude");
+  const configPath = path3.join(claudeDir, ".flywheel.json");
+  try {
+    if (fs5.existsSync(configPath)) {
+      const content = fs5.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content);
+      return { ...DEFAULT_CONFIG, ...config };
+    }
+  } catch (err) {
+    console.error("[Flywheel] Failed to load .flywheel.json:", err);
+  }
+  return DEFAULT_CONFIG;
+}
+var RECURRING_TAG_PATTERNS = [
+  "habit",
+  "habits",
+  "daily",
+  "weekly",
+  "monthly",
+  "recurring",
+  "routine",
+  "template"
+];
+var FOLDER_PATTERNS = {
+  daily_notes: ["daily", "dailies", "journal", "journals", "daily-notes", "daily_notes"],
+  weekly_notes: ["weekly", "weeklies", "weekly-notes", "weekly_notes"],
+  monthly_notes: ["monthly", "monthlies", "monthly-notes", "monthly_notes"],
+  quarterly_notes: ["quarterly", "quarterlies", "quarterly-notes", "quarterly_notes"],
+  yearly_notes: ["yearly", "yearlies", "annual", "yearly-notes", "yearly_notes"],
+  templates: ["template", "templates"]
+};
+function extractFolders(index) {
+  const folders = /* @__PURE__ */ new Set();
+  for (const notePath of index.notes.keys()) {
+    const dir = path3.dirname(notePath);
+    if (dir && dir !== ".") {
+      const parts = dir.split(/[/\\]/);
+      for (let i = 1; i <= parts.length; i++) {
+        folders.add(parts.slice(0, i).join("/"));
+      }
+    }
+  }
+  return Array.from(folders).sort((a, b) => {
+    const depthA = (a.match(/\//g) || []).length;
+    const depthB = (b.match(/\//g) || []).length;
+    return depthA - depthB;
+  });
+}
+function findMatchingFolder(folders, patterns) {
+  const lowerPatterns = patterns.map((p) => p.toLowerCase());
+  for (const folder of folders) {
+    const folderName = path3.basename(folder).toLowerCase();
+    if (lowerPatterns.includes(folderName)) {
+      return folder;
+    }
+  }
+  return void 0;
+}
+function inferConfig(index, vaultPath2) {
+  const inferred = {
+    exclude_task_tags: [],
+    paths: {}
+  };
+  if (vaultPath2) {
+    inferred.vault_name = path3.basename(vaultPath2);
+  }
+  const folders = extractFolders(index);
+  const detectedPath = findMatchingFolder(folders, FOLDER_PATTERNS.daily_notes);
+  if (detectedPath) inferred.paths.daily_notes = detectedPath;
+  const weeklyPath = findMatchingFolder(folders, FOLDER_PATTERNS.weekly_notes);
+  if (weeklyPath) inferred.paths.weekly_notes = weeklyPath;
+  const monthlyPath = findMatchingFolder(folders, FOLDER_PATTERNS.monthly_notes);
+  if (monthlyPath) inferred.paths.monthly_notes = monthlyPath;
+  const quarterlyPath = findMatchingFolder(folders, FOLDER_PATTERNS.quarterly_notes);
+  if (quarterlyPath) inferred.paths.quarterly_notes = quarterlyPath;
+  const yearlyPath = findMatchingFolder(folders, FOLDER_PATTERNS.yearly_notes);
+  if (yearlyPath) inferred.paths.yearly_notes = yearlyPath;
+  const templatesPath = findMatchingFolder(folders, FOLDER_PATTERNS.templates);
+  if (templatesPath) inferred.paths.templates = templatesPath;
+  for (const tag of index.tags.keys()) {
+    const lowerTag = tag.toLowerCase();
+    if (RECURRING_TAG_PATTERNS.some((pattern) => lowerTag.includes(pattern))) {
+      inferred.exclude_task_tags.push(tag);
+    }
+  }
+  return inferred;
+}
+function saveConfig(vaultPath2, inferred, existing) {
+  const claudeDir = path3.join(vaultPath2, ".claude");
+  const configPath = path3.join(claudeDir, ".flywheel.json");
+  try {
+    if (!fs5.existsSync(claudeDir)) {
+      fs5.mkdirSync(claudeDir, { recursive: true });
+    }
+    const mergedPaths = {
+      ...inferred.paths,
+      ...existing?.paths
+    };
+    const merged = {
+      ...DEFAULT_CONFIG,
+      ...inferred,
+      ...existing,
+      // Only include paths if there are any detected values
+      ...Object.keys(mergedPaths).length > 0 ? { paths: mergedPaths } : {}
+    };
+    const content = JSON.stringify(merged, null, 2);
+    fs5.writeFileSync(configPath, content, "utf-8");
+    console.error(`[Flywheel] Saved .claude/.flywheel.json`);
+  } catch (err) {
+    console.error("[Flywheel] Failed to save .claude/.flywheel.json:", err);
+  }
+}
+
+// src/tools/system.ts
+function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfig) {
+  const RefreshIndexOutputSchema = {
+    success: z5.boolean().describe("Whether the refresh succeeded"),
+    notes_count: z5.number().describe("Number of notes indexed"),
+    entities_count: z5.number().describe("Number of entities (titles + aliases)"),
+    duration_ms: z5.number().describe("Time taken to rebuild index")
+  };
+  server2.registerTool(
+    "refresh_index",
+    {
+      title: "Refresh Index",
+      description: "Rebuild the vault index without restarting the server. Use after making changes to notes in Obsidian.",
+      inputSchema: {},
+      outputSchema: RefreshIndexOutputSchema
+    },
+    async () => {
+      const vaultPath2 = getVaultPath();
+      const startTime = Date.now();
+      setIndexState("building");
+      setIndexError(null);
+      try {
+        const newIndex = await buildVaultIndex(vaultPath2);
+        setIndex(newIndex);
+        setIndexState("ready");
+        if (setConfig) {
+          const existing = loadConfig(vaultPath2);
+          const inferred = inferConfig(newIndex, vaultPath2);
+          saveConfig(vaultPath2, inferred, existing);
+          setConfig(loadConfig(vaultPath2));
+        }
+        const output = {
+          success: true,
+          notes_count: newIndex.notes.size,
+          entities_count: newIndex.entities.size,
+          duration_ms: Date.now() - startTime
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(output, null, 2)
+            }
+          ],
+          structuredContent: output
+        };
+      } catch (err) {
+        setIndexState("error");
+        setIndexError(err instanceof Error ? err : new Error(String(err)));
+        const output = {
+          success: false,
+          notes_count: 0,
+          entities_count: 0,
+          duration_ms: Date.now() - startTime
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error refreshing index: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          structuredContent: output
+        };
+      }
+    }
+  );
+  const GetAllEntitiesOutputSchema = {
+    entity_count: z5.number().describe("Total number of entities"),
+    entities: z5.array(
+      z5.object({
+        name: z5.string().describe("Entity name (title or alias)"),
+        path: z5.string().describe("Path to the note"),
+        is_alias: z5.boolean().describe("Whether this is an alias vs title")
+      })
+    ).describe("List of all entities")
+  };
+  server2.registerTool(
+    "get_all_entities",
+    {
+      title: "Get All Entities",
+      description: "Get all linkable entities in the vault (note titles and aliases). Useful for understanding what can be linked to.",
+      inputSchema: {
+        include_aliases: z5.boolean().default(true).describe("Include aliases in addition to titles"),
+        limit: z5.number().optional().describe("Maximum number of entities to return")
+      },
+      outputSchema: GetAllEntitiesOutputSchema
+    },
+    async ({
+      include_aliases,
+      limit: requestedLimit
+    }) => {
+      requireIndex();
+      const index = getIndex();
+      const limit = requestedLimit ? Math.min(requestedLimit, MAX_LIMIT) : MAX_LIMIT;
+      const entities = [];
+      for (const note of index.notes.values()) {
+        entities.push({
+          name: note.title,
+          path: note.path,
+          is_alias: false
+        });
+        if (include_aliases) {
+          for (const alias of note.aliases) {
+            entities.push({
+              name: alias,
+              path: note.path,
+              is_alias: true
+            });
+          }
+        }
+      }
+      entities.sort((a, b) => a.name.localeCompare(b.name));
+      const limitedEntities = entities.slice(0, limit);
+      const output = {
+        entity_count: limitedEntities.length,
+        entities: limitedEntities
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const GetRecentNotesOutputSchema = {
+    count: z5.number().describe("Number of notes returned"),
+    days: z5.number().describe("Number of days looked back"),
+    notes: z5.array(
+      z5.object({
+        path: z5.string().describe("Path to the note"),
+        title: z5.string().describe("Note title"),
+        modified: z5.string().describe("Last modified date (ISO format)"),
+        tags: z5.array(z5.string()).describe("Tags on this note")
+      })
+    ).describe("List of recently modified notes")
+  };
+  server2.registerTool(
+    "get_recent_notes",
+    {
+      title: "Get Recent Notes",
+      description: "Get notes modified within the last N days. Useful for generating reviews and understanding recent activity.",
+      inputSchema: {
+        days: z5.number().default(7).describe("Number of days to look back"),
+        limit: z5.number().default(50).describe("Maximum number of notes to return"),
+        folder: z5.string().optional().describe("Limit to notes in this folder")
+      },
+      outputSchema: GetRecentNotesOutputSchema
+    },
+    async ({
+      days,
+      limit: requestedLimit,
+      folder
+    }) => {
+      requireIndex();
+      const index = getIndex();
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const cutoffDate = /* @__PURE__ */ new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - days);
+      const recentNotes = [];
+      for (const note of index.notes.values()) {
+        if (folder && !note.path.startsWith(folder)) {
+          continue;
+        }
+        if (note.modified >= cutoffDate) {
+          recentNotes.push({
+            path: note.path,
+            title: note.title,
+            modified: note.modified.toISOString(),
+            tags: note.tags,
+            modifiedDate: note.modified
+          });
+        }
+      }
+      recentNotes.sort(
+        (a, b) => b.modifiedDate.getTime() - a.modifiedDate.getTime()
+      );
+      const limitedNotes = recentNotes.slice(0, limit);
+      const output = {
+        count: limitedNotes.length,
+        days,
+        notes: limitedNotes.map((n) => ({
+          path: n.path,
+          title: n.title,
+          modified: n.modified,
+          tags: n.tags
+        }))
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const GetUnlinkedMentionsOutputSchema = {
+    entity: z5.string().describe("The entity searched for"),
+    resolved_path: z5.string().optional().describe("Path of the note this entity refers to"),
+    mention_count: z5.number().describe("Total unlinked mentions found"),
+    mentions: z5.array(
+      z5.object({
+        path: z5.string().describe("Path of note with unlinked mention"),
+        line: z5.number().describe("Line number of mention"),
+        context: z5.string().describe("Surrounding text")
+      })
+    ).describe("List of unlinked mentions")
+  };
+  server2.registerTool(
+    "get_unlinked_mentions",
+    {
+      title: "Get Unlinked Mentions",
+      description: "Find places where an entity (note title or alias) is mentioned in text but not linked. Useful for finding linking opportunities.",
+      inputSchema: {
+        entity: z5.string().describe('Entity to search for (e.g., "John Smith")'),
+        limit: z5.number().default(50).describe("Maximum number of mentions to return")
+      },
+      outputSchema: GetUnlinkedMentionsOutputSchema
+    },
+    async ({
+      entity,
+      limit: requestedLimit
+    }) => {
+      requireIndex();
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const normalizedEntity = entity.toLowerCase();
+      const resolvedPath = index.entities.get(normalizedEntity);
+      const mentions = [];
+      for (const note of index.notes.values()) {
+        if (resolvedPath && note.path === resolvedPath) {
+          continue;
+        }
+        try {
+          const fullPath = path4.join(vaultPath2, note.path);
+          const content = await fs6.promises.readFile(fullPath, "utf-8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lowerLine = line.toLowerCase();
+            if (!lowerLine.includes(normalizedEntity)) {
+              continue;
+            }
+            const linkPattern = new RegExp(
+              `\\[\\[[^\\]]*${entity.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\]]*\\]\\]`,
+              "i"
+            );
+            if (linkPattern.test(line)) {
+              continue;
+            }
+            mentions.push({
+              path: note.path,
+              line: i + 1,
+              context: line.trim().slice(0, 200)
+            });
+            if (mentions.length >= limit) {
+              break;
+            }
+          }
+        } catch {
+        }
+        if (mentions.length >= limit) {
+          break;
+        }
+      }
+      const output = {
+        entity,
+        resolved_path: resolvedPath,
+        mention_count: mentions.length,
+        mentions
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const GetNoteMetadataOutputSchema = {
+    path: z5.string().describe("Path to the note"),
+    title: z5.string().describe("Note title"),
+    exists: z5.boolean().describe("Whether the note exists"),
+    frontmatter: z5.record(z5.unknown()).describe("Frontmatter properties"),
+    tags: z5.array(z5.string()).describe("Tags on this note"),
+    aliases: z5.array(z5.string()).describe("Aliases for this note"),
+    outlink_count: z5.number().describe("Number of outgoing links"),
+    backlink_count: z5.number().describe("Number of incoming links"),
+    word_count: z5.number().optional().describe("Approximate word count"),
+    created: z5.string().optional().describe("Created date (ISO format)"),
+    modified: z5.string().describe("Last modified date (ISO format)")
+  };
+  server2.registerTool(
+    "get_note_metadata",
+    {
+      title: "Get Note Metadata",
+      description: "Get metadata about a note (frontmatter, tags, link counts) without reading full content. Useful for quick analysis.",
+      inputSchema: {
+        path: z5.string().describe("Path to the note"),
+        include_word_count: z5.boolean().default(false).describe("Count words (requires reading file)")
+      },
+      outputSchema: GetNoteMetadataOutputSchema
+    },
+    async ({
+      path: notePath,
+      include_word_count
+    }) => {
+      requireIndex();
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      let resolvedPath = notePath;
+      if (!notePath.endsWith(".md")) {
+        const resolved = index.entities.get(notePath.toLowerCase());
+        if (resolved) {
+          resolvedPath = resolved;
+        } else {
+          resolvedPath = notePath + ".md";
+        }
+      }
+      const note = index.notes.get(resolvedPath);
+      if (!note) {
+        const output2 = {
+          path: resolvedPath,
+          title: resolvedPath.replace(/\.md$/, "").split("/").pop() || "",
+          exists: false,
+          frontmatter: {},
+          tags: [],
+          aliases: [],
+          outlink_count: 0,
+          backlink_count: 0,
+          modified: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(output2, null, 2)
+            }
+          ],
+          structuredContent: output2
+        };
+      }
+      const normalizedPath = resolvedPath.toLowerCase().replace(/\.md$/, "");
+      const backlinks = index.backlinks.get(normalizedPath) || [];
+      let wordCount;
+      if (include_word_count) {
+        try {
+          const fullPath = path4.join(vaultPath2, resolvedPath);
+          const content = await fs6.promises.readFile(fullPath, "utf-8");
+          wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
+        } catch {
+        }
+      }
+      const output = {
+        path: note.path,
+        title: note.title,
+        exists: true,
+        frontmatter: note.frontmatter,
+        tags: note.tags,
+        aliases: note.aliases,
+        outlink_count: note.outlinks.length,
+        backlink_count: backlinks.length,
+        word_count: wordCount,
+        created: note.created?.toISOString(),
+        modified: note.modified.toISOString()
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+  const GetFolderStructureOutputSchema = {
+    folder_count: z5.number().describe("Total number of folders"),
+    folders: z5.array(
+      z5.object({
+        path: z5.string().describe("Folder path"),
+        note_count: z5.number().describe("Number of notes in this folder"),
+        subfolder_count: z5.number().describe("Number of direct subfolders")
+      })
+    ).describe("List of folders with note counts")
+  };
+  server2.registerTool(
+    "get_folder_structure",
+    {
+      title: "Get Folder Structure",
+      description: "Get the folder structure of the vault with note counts. Useful for understanding vault organization.",
+      inputSchema: {},
+      outputSchema: GetFolderStructureOutputSchema
+    },
+    async () => {
+      requireIndex();
+      const index = getIndex();
+      const folderCounts = /* @__PURE__ */ new Map();
+      const subfolders = /* @__PURE__ */ new Map();
+      for (const note of index.notes.values()) {
+        const parts = note.path.split("/");
+        if (parts.length === 1) {
+          folderCounts.set("/", (folderCounts.get("/") || 0) + 1);
+          continue;
+        }
+        const folderPath = parts.slice(0, -1).join("/");
+        folderCounts.set(folderPath, (folderCounts.get(folderPath) || 0) + 1);
+        for (let i = 1; i < parts.length - 1; i++) {
+          const parent = parts.slice(0, i).join("/") || "/";
+          const child = parts.slice(0, i + 1).join("/");
+          if (!subfolders.has(parent)) {
+            subfolders.set(parent, /* @__PURE__ */ new Set());
+          }
+          subfolders.get(parent).add(child);
+          if (!folderCounts.has(parent)) {
+            folderCounts.set(parent, 0);
+          }
+        }
+      }
+      const folders = [];
+      for (const [folderPath, noteCount] of folderCounts) {
+        folders.push({
+          path: folderPath,
+          note_count: noteCount,
+          subfolder_count: subfolders.get(folderPath)?.size || 0
+        });
+      }
+      folders.sort((a, b) => a.path.localeCompare(b.path));
+      const output = {
+        folder_count: folders.length,
+        folders
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+}
+
+// src/tools/primitives.ts
+import { z as z6 } from "zod";
+
+// src/tools/temporal.ts
+function getNotesModifiedOn(index, date) {
+  const targetDate = new Date(date);
+  const targetDay = targetDate.toISOString().split("T")[0];
+  const results = [];
+  for (const note of index.notes.values()) {
+    const noteDay = note.modified.toISOString().split("T")[0];
+    if (noteDay === targetDay) {
+      results.push({
+        path: note.path,
+        title: note.title,
+        created: note.created,
+        modified: note.modified
+      });
+    }
+  }
+  return results.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+}
+function getNotesInRange(index, startDate, endDate) {
+  const start = new Date(startDate);
+  start.setHours(0, 0, 0, 0);
+  const end = new Date(endDate);
+  end.setHours(23, 59, 59, 999);
+  const results = [];
+  for (const note of index.notes.values()) {
+    if (note.modified >= start && note.modified <= end) {
+      results.push({
+        path: note.path,
+        title: note.title,
+        created: note.created,
+        modified: note.modified
+      });
+    }
+  }
+  return results.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+}
+function getStaleNotes(index, days, minBacklinks = 0) {
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+  const results = [];
+  for (const note of index.notes.values()) {
+    if (note.modified < cutoff) {
+      const backlinkCount = getBacklinksForNote(index, note.path).length;
+      if (backlinkCount >= minBacklinks) {
+        const daysSince = Math.floor(
+          (Date.now() - note.modified.getTime()) / (1e3 * 60 * 60 * 24)
+        );
+        results.push({
+          path: note.path,
+          title: note.title,
+          backlink_count: backlinkCount,
+          days_since_modified: daysSince,
+          modified: note.modified
+        });
+      }
+    }
+  }
+  return results.sort((a, b) => {
+    if (b.backlink_count !== a.backlink_count) {
+      return b.backlink_count - a.backlink_count;
+    }
+    return b.days_since_modified - a.days_since_modified;
+  });
+}
+function getContemporaneousNotes(index, path11, hours = 24) {
+  const targetNote = index.notes.get(path11);
+  if (!targetNote) {
+    return [];
+  }
+  const targetTime = targetNote.modified.getTime();
+  const windowMs = hours * 60 * 60 * 1e3;
+  const results = [];
+  for (const note of index.notes.values()) {
+    if (note.path === path11) continue;
+    const timeDiff = Math.abs(note.modified.getTime() - targetTime);
+    if (timeDiff <= windowMs) {
+      results.push({
+        path: note.path,
+        title: note.title,
+        modified: note.modified,
+        time_diff_hours: Math.round(timeDiff / (1e3 * 60 * 60) * 10) / 10
+      });
+    }
+  }
+  return results.sort((a, b) => a.time_diff_hours - b.time_diff_hours);
+}
+function getActivitySummary(index, days) {
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+  cutoff.setHours(0, 0, 0, 0);
+  const dailyCounts = {};
+  let notesModified = 0;
+  let notesCreated = 0;
+  for (const note of index.notes.values()) {
+    if (note.modified >= cutoff) {
+      notesModified++;
+      const day = note.modified.toISOString().split("T")[0];
+      dailyCounts[day] = (dailyCounts[day] || 0) + 1;
+    }
+    if (note.created && note.created >= cutoff) {
+      notesCreated++;
+    }
+  }
+  let mostActiveDay = null;
+  let maxCount = 0;
+  for (const [day, count] of Object.entries(dailyCounts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      mostActiveDay = day;
+    }
+  }
+  return {
+    period_days: days,
+    notes_modified: notesModified,
+    notes_created: notesCreated,
+    most_active_day: mostActiveDay,
+    daily_counts: dailyCounts
+  };
+}
+
+// src/tools/structure.ts
+import * as fs7 from "fs";
+import * as path5 from "path";
+var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
+function extractHeadings(content) {
+  const lines = content.split("\n");
+  const headings = [];
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const match = line.match(HEADING_REGEX);
+    if (match) {
+      headings.push({
+        level: match[1].length,
+        text: match[2].trim(),
+        line: i + 1
+        // 1-indexed
+      });
+    }
+  }
+  return headings;
+}
+function buildSections(headings, totalLines) {
+  if (headings.length === 0) return [];
+  const sections = [];
+  const stack = [];
+  for (let i = 0; i < headings.length; i++) {
+    const heading = headings[i];
+    const nextHeading = headings[i + 1];
+    const lineEnd = nextHeading ? nextHeading.line - 1 : totalLines;
+    const section = {
+      heading,
+      line_start: heading.line,
+      line_end: lineEnd,
+      subsections: []
+    };
+    while (stack.length > 0 && stack[stack.length - 1].heading.level >= heading.level) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      sections.push(section);
+    } else {
+      stack[stack.length - 1].subsections.push(section);
+    }
+    stack.push(section);
+  }
+  return sections;
+}
+async function getNoteStructure(index, notePath, vaultPath2) {
+  const note = index.notes.get(notePath);
+  if (!note) return null;
+  const absolutePath = path5.join(vaultPath2, notePath);
+  let content;
+  try {
+    content = await fs7.promises.readFile(absolutePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split("\n");
+  const headings = extractHeadings(content);
+  const sections = buildSections(headings, lines.length);
+  const contentWithoutCode = content.replace(/```[\s\S]*?```/g, "");
+  const words = contentWithoutCode.split(/\s+/).filter((w) => w.length > 0);
+  return {
+    path: notePath,
+    headings,
+    sections,
+    word_count: words.length,
+    line_count: lines.length
+  };
+}
+async function getHeadings(index, notePath, vaultPath2) {
+  const note = index.notes.get(notePath);
+  if (!note) return null;
+  const absolutePath = path5.join(vaultPath2, notePath);
+  let content;
+  try {
+    content = await fs7.promises.readFile(absolutePath, "utf-8");
+  } catch {
+    return null;
+  }
+  return extractHeadings(content);
+}
+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);
+  let content;
+  try {
+    content = await fs7.promises.readFile(absolutePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split("\n");
+  const headings = extractHeadings(content);
+  const targetHeading = headings.find(
+    (h) => h.text.toLowerCase() === headingText.toLowerCase()
+  );
+  if (!targetHeading) return null;
+  let lineEnd = lines.length;
+  for (const h of headings) {
+    if (h.line > targetHeading.line) {
+      if (includeSubheadings) {
+        if (h.level <= targetHeading.level) {
+          lineEnd = h.line - 1;
+          break;
+        }
+      } else {
+        lineEnd = h.line - 1;
+        break;
+      }
+    }
+  }
+  const sectionLines = lines.slice(targetHeading.line, lineEnd);
+  const sectionContent = sectionLines.join("\n").trim();
+  return {
+    heading: targetHeading.text,
+    level: targetHeading.level,
+    content: sectionContent,
+    line_start: targetHeading.line,
+    line_end: lineEnd
+  };
+}
+async function findSections(index, headingPattern, vaultPath2, folder) {
+  const regex = new RegExp(headingPattern, "i");
+  const results = [];
+  for (const note of index.notes.values()) {
+    if (folder && !note.path.startsWith(folder)) continue;
+    const absolutePath = path5.join(vaultPath2, note.path);
+    let content;
+    try {
+      content = await fs7.promises.readFile(absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const headings = extractHeadings(content);
+    for (const heading of headings) {
+      if (regex.test(heading.text)) {
+        results.push({
+          path: note.path,
+          heading: heading.text,
+          level: heading.level,
+          line: heading.line
+        });
+      }
+    }
+  }
+  return results;
+}
+
+// src/tools/tasks.ts
+import * as fs8 from "fs";
+import * as path6 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/;
+var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
+function parseStatus(char) {
+  if (char === " ") return "open";
+  if (char === "-") return "cancelled";
+  return "completed";
+}
+function extractTags2(text) {
+  const tags = [];
+  let match;
+  TAG_REGEX2.lastIndex = 0;
+  while ((match = TAG_REGEX2.exec(text)) !== null) {
+    tags.push(match[1]);
+  }
+  return tags;
+}
+function extractDueDate(text) {
+  const match = text.match(DATE_REGEX);
+  return match ? match[1] : void 0;
+}
+async function extractTasksFromNote(notePath, absolutePath) {
+  let content;
+  try {
+    content = await fs8.promises.readFile(absolutePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const lines = content.split("\n");
+  const tasks = [];
+  let currentHeading;
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const headingMatch = line.match(HEADING_REGEX2);
+    if (headingMatch) {
+      currentHeading = headingMatch[2].trim();
+      continue;
+    }
+    const taskMatch = line.match(TASK_REGEX);
+    if (taskMatch) {
+      const statusChar = taskMatch[2];
+      const text = taskMatch[3].trim();
+      tasks.push({
+        path: notePath,
+        line: i + 1,
+        text,
+        status: parseStatus(statusChar),
+        raw: line,
+        context: currentHeading,
+        tags: extractTags2(text),
+        due_date: extractDueDate(text)
+      });
+    }
+  }
+  return tasks;
+}
+async function getAllTasks(index, vaultPath2, options = {}) {
+  const { status = "all", folder, tag, excludeTags = [], limit } = 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 tasks = await extractTasksFromNote(note.path, absolutePath);
+    allTasks.push(...tasks);
+  }
+  let filteredTasks = allTasks;
+  if (status !== "all") {
+    filteredTasks = allTasks.filter((t) => t.status === status);
+  }
+  if (tag) {
+    filteredTasks = filteredTasks.filter((t) => t.tags.includes(tag));
+  }
+  if (excludeTags.length > 0) {
+    filteredTasks = filteredTasks.filter(
+      (t) => !excludeTags.some((excludeTag) => t.tags.includes(excludeTag))
+    );
+  }
+  const openCount = allTasks.filter((t) => t.status === "open").length;
+  const completedCount = allTasks.filter((t) => t.status === "completed").length;
+  const cancelledCount = allTasks.filter((t) => t.status === "cancelled").length;
+  const returnTasks = limit ? filteredTasks.slice(0, limit) : filteredTasks;
+  return {
+    total: allTasks.length,
+    open_count: openCount,
+    completed_count: completedCount,
+    cancelled_count: cancelledCount,
+    tasks: returnTasks
+  };
+}
+async function getTasksFromNote(index, notePath, vaultPath2, excludeTags = []) {
+  const note = index.notes.get(notePath);
+  if (!note) return null;
+  const absolutePath = path6.join(vaultPath2, notePath);
+  let tasks = await extractTasksFromNote(notePath, absolutePath);
+  if (excludeTags.length > 0) {
+    tasks = tasks.filter(
+      (t) => !excludeTags.some((excludeTag) => t.tags.includes(excludeTag))
+    );
+  }
+  return tasks;
+}
+async function getTasksWithDueDates(index, vaultPath2, options = {}) {
+  const { status = "open", folder, excludeTags } = options;
+  const result = await getAllTasks(index, vaultPath2, { status, folder, excludeTags });
+  return result.tasks.filter((t) => t.due_date).sort((a, b) => {
+    const dateA = a.due_date || "";
+    const dateB = b.due_date || "";
+    return dateA.localeCompare(dateB);
+  });
+}
+
+// src/tools/graphAdvanced.ts
+function getLinkPath(index, fromPath, toPath, maxDepth = 10) {
+  const from = index.notes.has(fromPath) ? fromPath : resolveTarget(index, fromPath);
+  const to = index.notes.has(toPath) ? toPath : resolveTarget(index, toPath);
+  if (!from || !to) {
+    return { exists: false, path: [], length: -1 };
+  }
+  if (from === to) {
+    return { exists: true, path: [from], length: 0 };
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [{ path: [from], current: from }];
+  while (queue.length > 0) {
+    const { path: currentPath, current } = queue.shift();
+    if (currentPath.length > maxDepth) {
+      continue;
+    }
+    const note = index.notes.get(current);
+    if (!note) continue;
+    for (const link of note.outlinks) {
+      const targetPath = resolveTarget(index, link.target);
+      if (!targetPath) continue;
+      if (targetPath === to) {
+        const fullPath = [...currentPath, targetPath];
+        return {
+          exists: true,
+          path: fullPath,
+          length: fullPath.length - 1
+        };
+      }
+      if (!visited.has(targetPath)) {
+        visited.add(targetPath);
+        queue.push({
+          path: [...currentPath, targetPath],
+          current: targetPath
+        });
+      }
+    }
+  }
+  return { exists: false, path: [], length: -1 };
+}
+function getCommonNeighbors(index, noteAPath, noteBPath) {
+  const noteA = index.notes.get(noteAPath);
+  const noteB = index.notes.get(noteBPath);
+  if (!noteA || !noteB) return [];
+  const aTargets = /* @__PURE__ */ new Map();
+  for (const link of noteA.outlinks) {
+    const resolved = resolveTarget(index, link.target);
+    if (resolved) {
+      aTargets.set(resolved, link.line);
+    }
+  }
+  const common = [];
+  for (const link of noteB.outlinks) {
+    const resolved = resolveTarget(index, link.target);
+    if (resolved && aTargets.has(resolved)) {
+      const targetNote = index.notes.get(resolved);
+      if (targetNote) {
+        common.push({
+          path: resolved,
+          title: targetNote.title,
+          linked_from_a_line: aTargets.get(resolved),
+          linked_from_b_line: link.line
+        });
+      }
+    }
+  }
+  return common;
+}
+function findBidirectionalLinks(index, notePath) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const notesToCheck = notePath ? [index.notes.get(notePath)].filter(Boolean) : Array.from(index.notes.values());
+  for (const noteA of notesToCheck) {
+    if (!noteA) continue;
+    for (const linkFromA of noteA.outlinks) {
+      const targetPath = resolveTarget(index, linkFromA.target);
+      if (!targetPath) continue;
+      const noteB = index.notes.get(targetPath);
+      if (!noteB) continue;
+      for (const linkFromB of noteB.outlinks) {
+        const backTarget = resolveTarget(index, linkFromB.target);
+        if (backTarget === noteA.path) {
+          const pairKey = [noteA.path, noteB.path].sort().join("|");
+          if (!seen.has(pairKey)) {
+            seen.add(pairKey);
+            results.push({
+              noteA: noteA.path,
+              noteB: noteB.path,
+              a_to_b_line: linkFromA.line,
+              b_to_a_line: linkFromB.line
+            });
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function findDeadEnds(index, folder, minBacklinks = 1) {
+  const results = [];
+  for (const note of index.notes.values()) {
+    if (folder && !note.path.startsWith(folder)) continue;
+    if (note.outlinks.length === 0) {
+      const backlinkCount = getBacklinksForNote(index, note.path).length;
+      if (backlinkCount >= minBacklinks) {
+        results.push({
+          path: note.path,
+          title: note.title,
+          backlink_count: backlinkCount
+        });
+      }
+    }
+  }
+  return results.sort((a, b) => b.backlink_count - a.backlink_count);
+}
+function findSources(index, folder, minOutlinks = 1) {
+  const results = [];
+  for (const note of index.notes.values()) {
+    if (folder && !note.path.startsWith(folder)) continue;
+    const backlinkCount = getBacklinksForNote(index, note.path).length;
+    if (note.outlinks.length >= minOutlinks && backlinkCount === 0) {
+      results.push({
+        path: note.path,
+        title: note.title,
+        outlink_count: note.outlinks.length
+      });
+    }
+  }
+  return results.sort((a, b) => b.outlink_count - a.outlink_count);
+}
+function getConnectionStrength(index, noteAPath, noteBPath) {
+  const noteA = index.notes.get(noteAPath);
+  const noteB = index.notes.get(noteBPath);
+  if (!noteA || !noteB) {
+    return {
+      score: 0,
+      factors: {
+        mutual_link: false,
+        shared_tags: [],
+        shared_outlinks: 0,
+        same_folder: false
+      }
+    };
+  }
+  let score = 0;
+  const factors = {
+    mutual_link: false,
+    shared_tags: [],
+    shared_outlinks: 0,
+    same_folder: false
+  };
+  const aLinksToB = noteA.outlinks.some((l) => {
+    const resolved = resolveTarget(index, l.target);
+    return resolved === noteBPath;
+  });
+  const bLinksToA = noteB.outlinks.some((l) => {
+    const resolved = resolveTarget(index, l.target);
+    return resolved === noteAPath;
+  });
+  if (aLinksToB && bLinksToA) {
+    factors.mutual_link = true;
+    score += 3;
+  } else if (aLinksToB || bLinksToA) {
+    score += 1;
+  }
+  const tagsA = new Set(noteA.tags);
+  for (const tag of noteB.tags) {
+    if (tagsA.has(tag)) {
+      factors.shared_tags.push(tag);
+      score += 1;
+    }
+  }
+  const common = getCommonNeighbors(index, noteAPath, noteBPath);
+  factors.shared_outlinks = common.length;
+  score += common.length * 0.5;
+  const folderA = noteAPath.split("/").slice(0, -1).join("/");
+  const folderB = noteBPath.split("/").slice(0, -1).join("/");
+  if (folderA === folderB && folderA !== "") {
+    factors.same_folder = true;
+    score += 1;
+  }
+  return { score, factors };
+}
+
+// src/tools/frontmatter.ts
+function getValueType(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Date) return "date";
+  return typeof value;
+}
+function getFrontmatterSchema(index) {
+  const fieldMap = /* @__PURE__ */ new Map();
+  let notesWithFrontmatter = 0;
+  for (const note of index.notes.values()) {
+    const fm = note.frontmatter;
+    if (!fm || Object.keys(fm).length === 0) continue;
+    notesWithFrontmatter++;
+    for (const [key, value] of Object.entries(fm)) {
+      if (!fieldMap.has(key)) {
+        fieldMap.set(key, {
+          types: /* @__PURE__ */ new Set(),
+          count: 0,
+          examples: [],
+          notes: []
+        });
+      }
+      const info = fieldMap.get(key);
+      info.count++;
+      info.types.add(getValueType(value));
+      if (info.examples.length < 5) {
+        const valueStr = JSON.stringify(value);
+        const existingStrs = info.examples.map((e) => JSON.stringify(e));
+        if (!existingStrs.includes(valueStr)) {
+          info.examples.push(value);
+        }
+      }
+      if (info.notes.length < 5) {
+        info.notes.push(note.path);
+      }
+    }
+  }
+  const fields = Array.from(fieldMap.entries()).map(([name, info]) => ({
+    name,
+    types: Array.from(info.types),
+    count: info.count,
+    examples: info.examples,
+    notes_sample: info.notes
+  })).sort((a, b) => b.count - a.count);
+  return {
+    total_notes: index.notes.size,
+    notes_with_frontmatter: notesWithFrontmatter,
+    field_count: fields.length,
+    fields
+  };
+}
+function getFieldValues(index, fieldName) {
+  const valueMap = /* @__PURE__ */ new Map();
+  let totalWithField = 0;
+  for (const note of index.notes.values()) {
+    const value = note.frontmatter[fieldName];
+    if (value === void 0) continue;
+    totalWithField++;
+    const values = Array.isArray(value) ? value : [value];
+    for (const v of values) {
+      const key = JSON.stringify(v);
+      if (!valueMap.has(key)) {
+        valueMap.set(key, {
+          value: v,
+          count: 0,
+          notes: []
+        });
+      }
+      const info = valueMap.get(key);
+      info.count++;
+      info.notes.push(note.path);
+    }
+  }
+  const valuesList = Array.from(valueMap.values()).sort((a, b) => b.count - a.count);
+  return {
+    field: fieldName,
+    total_notes_with_field: totalWithField,
+    unique_values: valuesList.length,
+    values: valuesList
+  };
+}
+function findFrontmatterInconsistencies(index) {
+  const schema = getFrontmatterSchema(index);
+  const inconsistencies = [];
+  for (const field of schema.fields) {
+    if (field.types.length > 1) {
+      const examples = [];
+      for (const note of index.notes.values()) {
+        const value = note.frontmatter[field.name];
+        if (value === void 0) continue;
+        const type = getValueType(value);
+        if (!examples.some((e) => e.type === type)) {
+          examples.push({
+            type,
+            value,
+            note: note.path
+          });
+        }
+        if (examples.length >= field.types.length) break;
+      }
+      inconsistencies.push({
+        field: field.name,
+        types_found: field.types,
+        examples
+      });
+    }
+  }
+  return inconsistencies;
+}
+function validateFrontmatter(index, schema, folder) {
+  const results = [];
+  for (const note of index.notes.values()) {
+    if (folder && !note.path.startsWith(folder)) continue;
+    const issues = [];
+    for (const [fieldName, fieldSchema] of Object.entries(schema)) {
+      const value = note.frontmatter[fieldName];
+      if (fieldSchema.required && value === void 0) {
+        issues.push({
+          field: fieldName,
+          issue: "missing",
+          expected: "value required"
+        });
+        continue;
+      }
+      if (value === void 0) continue;
+      if (fieldSchema.type) {
+        const actualType = getValueType(value);
+        const allowedTypes = Array.isArray(fieldSchema.type) ? fieldSchema.type : [fieldSchema.type];
+        if (!allowedTypes.includes(actualType)) {
+          issues.push({
+            field: fieldName,
+            issue: "wrong_type",
+            expected: allowedTypes.join(" | "),
+            actual: actualType
+          });
+        }
+      }
+      if (fieldSchema.values) {
+        const valueStr = JSON.stringify(value);
+        const allowedStrs = fieldSchema.values.map((v) => JSON.stringify(v));
+        if (!allowedStrs.includes(valueStr)) {
+          issues.push({
+            field: fieldName,
+            issue: "invalid_value",
+            expected: fieldSchema.values.map((v) => String(v)).join(" | "),
+            actual: String(value)
+          });
+        }
+      }
+    }
+    if (issues.length > 0) {
+      results.push({
+        path: note.path,
+        issues
+      });
+    }
+  }
+  return results;
+}
+function findMissingFrontmatter(index, folderSchemas) {
+  const results = [];
+  for (const note of index.notes.values()) {
+    for (const [folder, requiredFields] of Object.entries(folderSchemas)) {
+      if (!note.path.startsWith(folder)) continue;
+      const missing = requiredFields.filter(
+        (field) => note.frontmatter[field] === void 0
+      );
+      if (missing.length > 0) {
+        results.push({
+          path: note.path,
+          folder,
+          missing_fields: missing
+        });
+      }
+    }
+  }
+  return results;
+}
+
+// src/tools/primitives.ts
+function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = () => ({})) {
+  server2.registerTool(
+    "get_notes_modified_on",
+    {
+      title: "Get Notes Modified On Date",
+      description: "Get all notes that were modified on a specific date.",
+      inputSchema: {
+        date: z6.string().describe("Date in YYYY-MM-DD format"),
+        limit: z6.number().default(50).describe("Maximum number of results to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ date, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allResults = getNotesModifiedOn(index, date);
+      const result = allResults.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          date,
+          total_count: allResults.length,
+          returned_count: result.length,
+          notes: result.map((n) => ({
+            ...n,
+            created: n.created?.toISOString(),
+            modified: n.modified.toISOString()
+          }))
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_notes_in_range",
+    {
+      title: "Get Notes In Date Range",
+      description: "Get all notes modified within a date range.",
+      inputSchema: {
+        start_date: z6.string().describe("Start date in YYYY-MM-DD format"),
+        end_date: z6.string().describe("End date in YYYY-MM-DD format"),
+        limit: z6.number().default(50).describe("Maximum number of results to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ start_date, end_date, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allResults = getNotesInRange(index, start_date, end_date);
+      const result = allResults.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          start_date,
+          end_date,
+          total_count: allResults.length,
+          returned_count: result.length,
+          notes: result.map((n) => ({
+            ...n,
+            created: n.created?.toISOString(),
+            modified: n.modified.toISOString()
+          }))
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_stale_notes",
+    {
+      title: "Get Stale Notes",
+      description: "Find important notes (by backlink count) that have not been modified recently.",
+      inputSchema: {
+        days: z6.number().describe("Notes not modified in this many days"),
+        min_backlinks: z6.number().default(1).describe("Minimum backlinks to be considered important"),
+        limit: z6.number().default(50).describe("Maximum results to return")
+      }
+    },
+    async ({ days, min_backlinks, limit: requestedLimit }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const result = getStaleNotes(index, days, min_backlinks).slice(0, limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          criteria: { days, min_backlinks },
+          count: result.length,
+          notes: result.map((n) => ({
+            ...n,
+            modified: n.modified.toISOString()
+          }))
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_contemporaneous_notes",
+    {
+      title: "Get Contemporaneous Notes",
+      description: "Find notes that were edited around the same time as a given note.",
+      inputSchema: {
+        path: z6.string().describe("Path to the reference note"),
+        hours: z6.number().default(24).describe("Time window in hours"),
+        limit: z6.number().default(50).describe("Maximum number of results to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ path: path11, hours, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allResults = getContemporaneousNotes(index, path11, hours);
+      const result = allResults.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          reference_note: path11,
+          window_hours: hours,
+          total_count: allResults.length,
+          returned_count: result.length,
+          notes: result.map((n) => ({
+            ...n,
+            modified: n.modified.toISOString()
+          }))
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_activity_summary",
+    {
+      title: "Get Activity Summary",
+      description: "Get a summary of vault activity over a period.",
+      inputSchema: {
+        days: z6.number().default(7).describe("Number of days to analyze")
+      }
+    },
+    async ({ days }) => {
+      const index = getIndex();
+      const result = getActivitySummary(index, days);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_note_structure",
+    {
+      title: "Get Note Structure",
+      description: "Get the heading structure and sections of a note.",
+      inputSchema: {
+        path: z6.string().describe("Path to the note")
+      }
+    },
+    async ({ path: path11 }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getNoteStructure(index, path11, vaultPath2);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path11 }, null, 2) }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_headings",
+    {
+      title: "Get Headings",
+      description: "Get all headings from a note (lightweight).",
+      inputSchema: {
+        path: z6.string().describe("Path to the note")
+      }
+    },
+    async ({ path: path11 }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getHeadings(index, path11, vaultPath2);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path11 }, null, 2) }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          path: path11,
+          heading_count: result.length,
+          headings: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_section_content",
+    {
+      title: "Get Section Content",
+      description: "Get the content under a specific heading in a note.",
+      inputSchema: {
+        path: z6.string().describe("Path to the note"),
+        heading: z6.string().describe("Heading text to find"),
+        include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
+      }
+    },
+    async ({ path: path11, heading, include_subheadings }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getSectionContent(index, path11, heading, vaultPath2, include_subheadings);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            error: "Section not found",
+            path: path11,
+            heading
+          }, null, 2) }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "find_sections",
+    {
+      title: "Find Sections",
+      description: "Find all sections across vault matching a heading pattern.",
+      inputSchema: {
+        pattern: z6.string().describe("Regex pattern to match heading text"),
+        folder: z6.string().optional().describe("Limit to notes in this folder"),
+        limit: z6.number().default(50).describe("Maximum number of results to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ pattern, folder, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const allResults = await findSections(index, pattern, vaultPath2, folder);
+      const result = allResults.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          pattern,
+          folder,
+          total_count: allResults.length,
+          returned_count: result.length,
+          sections: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_all_tasks",
+    {
+      title: "Get All Tasks",
+      description: "Get all tasks from the vault with filtering options.",
+      inputSchema: {
+        status: z6.enum(["open", "completed", "cancelled", "all"]).default("all").describe("Filter by task status"),
+        folder: z6.string().optional().describe("Limit to notes in this folder"),
+        tag: z6.string().optional().describe("Filter to tasks with this tag"),
+        limit: z6.number().default(25).describe("Maximum tasks to return")
+      }
+    },
+    async ({ status, folder, tag, limit: requestedLimit }) => {
+      const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const config = getConfig();
+      const result = await getAllTasks(index, vaultPath2, {
+        status,
+        folder,
+        tag,
+        limit,
+        excludeTags: config.exclude_task_tags
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_tasks_from_note",
+    {
+      title: "Get Tasks From Note",
+      description: "Get all tasks from a specific note.",
+      inputSchema: {
+        path: z6.string().describe("Path to the note")
+      }
+    },
+    async ({ path: path11 }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const config = getConfig();
+      const result = await getTasksFromNote(index, path11, vaultPath2, config.exclude_task_tags || []);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path11 }, null, 2) }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          path: path11,
+          task_count: result.length,
+          open: result.filter((t) => t.status === "open").length,
+          completed: result.filter((t) => t.status === "completed").length,
+          tasks: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_tasks_with_due_dates",
+    {
+      title: "Get Tasks With Due Dates",
+      description: "Get tasks that have due dates, sorted by date.",
+      inputSchema: {
+        status: z6.enum(["open", "completed", "cancelled", "all"]).default("open").describe("Filter by status"),
+        folder: z6.string().optional().describe("Limit to notes in this folder"),
+        limit: z6.number().default(25).describe("Maximum number of results to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ status, folder, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const config = getConfig();
+      const allResults = await getTasksWithDueDates(index, vaultPath2, {
+        status,
+        folder,
+        excludeTags: config.exclude_task_tags
+      });
+      const result = allResults.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          total_count: allResults.length,
+          returned_count: result.length,
+          tasks: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_incomplete_tasks",
+    {
+      title: "Get Incomplete Tasks",
+      description: "Get all incomplete (open) tasks from the vault. Simpler interface that defaults to open tasks only.",
+      inputSchema: {
+        folder: z6.string().optional().describe("Limit to notes in this folder"),
+        tag: z6.string().optional().describe("Filter to tasks with this tag"),
+        limit: z6.number().default(50).describe("Maximum tasks to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ folder, tag, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const config = getConfig();
+      const result = await getAllTasks(index, vaultPath2, {
+        status: "open",
+        folder,
+        tag,
+        limit: limit + offset,
+        excludeTags: config.exclude_task_tags
+      });
+      const paginatedTasks = result.tasks.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          total_incomplete: result.open_count,
+          returned_count: paginatedTasks.length,
+          tasks: paginatedTasks
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_link_path",
+    {
+      title: "Get Link Path",
+      description: "Find the shortest path of links between two notes.",
+      inputSchema: {
+        from: z6.string().describe("Starting note path"),
+        to: z6.string().describe("Target note path"),
+        max_depth: z6.number().default(10).describe("Maximum path length to search")
+      }
+    },
+    async ({ from, to, max_depth }) => {
+      const index = getIndex();
+      const result = getLinkPath(index, from, to, max_depth);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          from,
+          to,
+          ...result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_common_neighbors",
+    {
+      title: "Get Common Neighbors",
+      description: "Find notes that both specified notes link to.",
+      inputSchema: {
+        note_a: z6.string().describe("First note path"),
+        note_b: z6.string().describe("Second note path")
+      }
+    },
+    async ({ note_a, note_b }) => {
+      const index = getIndex();
+      const result = getCommonNeighbors(index, note_a, note_b);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          note_a,
+          note_b,
+          common_count: result.length,
+          common_neighbors: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "find_bidirectional_links",
+    {
+      title: "Find Bidirectional Links",
+      description: "Find pairs of notes that link to each other (mutual links).",
+      inputSchema: {
+        path: z6.string().optional().describe("Limit to links involving this note"),
+        limit: z6.number().default(50).describe("Maximum number of results to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ path: path11, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allResults = findBidirectionalLinks(index, path11);
+      const result = allResults.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          scope: path11 || "all",
+          total_count: allResults.length,
+          returned_count: result.length,
+          pairs: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "find_dead_ends",
+    {
+      title: "Find Dead Ends",
+      description: "Find notes with backlinks but no outgoing links (consume but do not contribute).",
+      inputSchema: {
+        folder: z6.string().optional().describe("Limit to notes in this folder"),
+        min_backlinks: z6.number().default(1).describe("Minimum backlinks required"),
+        limit: z6.number().default(50).describe("Maximum number of results to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ folder, min_backlinks, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allResults = findDeadEnds(index, folder, min_backlinks);
+      const result = allResults.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          criteria: { folder, min_backlinks },
+          total_count: allResults.length,
+          returned_count: result.length,
+          dead_ends: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "find_sources",
+    {
+      title: "Find Sources",
+      description: "Find notes with outgoing links but no backlinks (contribute but not referenced).",
+      inputSchema: {
+        folder: z6.string().optional().describe("Limit to notes in this folder"),
+        min_outlinks: z6.number().default(1).describe("Minimum outlinks required"),
+        limit: z6.number().default(50).describe("Maximum number of results to return"),
+        offset: z6.number().default(0).describe("Number of results to skip (for pagination)")
+      }
+    },
+    async ({ folder, min_outlinks, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const allResults = findSources(index, folder, min_outlinks);
+      const result = allResults.slice(offset, offset + limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          criteria: { folder, min_outlinks },
+          total_count: allResults.length,
+          returned_count: result.length,
+          sources: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_connection_strength",
+    {
+      title: "Get Connection Strength",
+      description: "Calculate the connection strength between two notes based on various factors.",
+      inputSchema: {
+        note_a: z6.string().describe("First note path"),
+        note_b: z6.string().describe("Second note path")
+      }
+    },
+    async ({ note_a, note_b }) => {
+      const index = getIndex();
+      const result = getConnectionStrength(index, note_a, note_b);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          note_a,
+          note_b,
+          ...result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_frontmatter_schema",
+    {
+      title: "Get Frontmatter Schema",
+      description: "Analyze all frontmatter fields used across the vault.",
+      inputSchema: {}
+    },
+    async () => {
+      const index = getIndex();
+      const result = getFrontmatterSchema(index);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_field_values",
+    {
+      title: "Get Field Values",
+      description: "Get all unique values for a specific frontmatter field.",
+      inputSchema: {
+        field: z6.string().describe("Frontmatter field name")
+      }
+    },
+    async ({ field }) => {
+      const index = getIndex();
+      const result = getFieldValues(index, field);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "find_frontmatter_inconsistencies",
+    {
+      title: "Find Frontmatter Inconsistencies",
+      description: "Find fields that have multiple different types across notes.",
+      inputSchema: {}
+    },
+    async () => {
+      const index = getIndex();
+      const result = findFrontmatterInconsistencies(index);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          inconsistency_count: result.length,
+          inconsistencies: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "validate_frontmatter",
+    {
+      title: "Validate Frontmatter",
+      description: "Validate notes against a schema. Returns notes with issues (missing fields, wrong types, invalid values).",
+      inputSchema: {
+        schema: z6.record(z6.object({
+          required: z6.boolean().optional().describe("Whether field is required"),
+          type: z6.union([z6.string(), z6.array(z6.string())]).optional().describe("Expected type(s)"),
+          values: z6.array(z6.unknown()).optional().describe("Allowed values")
+        })).describe("Schema defining expected frontmatter fields"),
+        folder: z6.string().optional().describe("Limit to notes in this folder")
+      }
+    },
+    async (params) => {
+      const index = getIndex();
+      const result = validateFrontmatter(
+        index,
+        params.schema,
+        params.folder
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          notes_with_issues: result.length,
+          results: result
+        }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "find_missing_frontmatter",
+    {
+      title: "Find Missing Frontmatter",
+      description: "Find notes missing expected frontmatter fields based on their folder.",
+      inputSchema: {
+        folder_schemas: z6.record(z6.array(z6.string())).describe("Map of folder paths to required field names")
+      }
+    },
+    async (params) => {
+      const index = getIndex();
+      const result = findMissingFrontmatter(
+        index,
+        params.folder_schemas
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          notes_with_missing_fields: result.length,
+          results: result
+        }, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/periodic.ts
+import { z as z7 } from "zod";
+var DATE_PATTERNS = {
+  daily: [
+    { name: "YYYY-MM-DD", regex: /^\d{4}-\d{2}-\d{2}\.md$/, format: "YYYY-MM-DD" },
+    { name: "YYYY-MM-DD-*", regex: /^\d{4}-\d{2}-\d{2}-.+\.md$/, format: "YYYY-MM-DD-*" },
+    { name: "DD-MM-YYYY", regex: /^\d{2}-\d{2}-\d{4}\.md$/, format: "DD-MM-YYYY" }
+  ],
+  weekly: [
+    { name: "YYYY-WXX", regex: /^\d{4}-W\d{2}\.md$/, format: "YYYY-WXX" },
+    { name: "YYYY-[W]XX", regex: /^\d{4}-\[W\]\d{2}\.md$/, format: "YYYY-[W]XX" }
+  ],
+  monthly: [
+    { name: "YYYY-MM", regex: /^\d{4}-\d{2}\.md$/, format: "YYYY-MM" }
+  ],
+  quarterly: [
+    { name: "YYYY-QX", regex: /^\d{4}-Q[1-4]\.md$/, format: "YYYY-QX" }
+  ],
+  yearly: [
+    { name: "YYYY", regex: /^\d{4}\.md$/, format: "YYYY" }
+  ]
+};
+var COMMON_FOLDERS = {
+  daily: ["daily-notes", "Daily", "journal", "Journal", "dailies"],
+  weekly: ["weekly-notes", "Weekly", "weeklies"],
+  monthly: ["monthly-notes", "Monthly", "monthlies"],
+  quarterly: ["quarterly-notes", "Quarterly", "quarterlies"],
+  yearly: ["yearly-notes", "Yearly", "yearlies"]
+};
+function getCurrentPeriodPath(type, folder, pattern) {
+  const now = /* @__PURE__ */ new Date();
+  let filename = "";
+  switch (pattern) {
+    case "YYYY-MM-DD":
+      filename = now.toISOString().split("T")[0];
+      break;
+    case "YYYY-WXX": {
+      const week = getISOWeek(now);
+      filename = `${now.getFullYear()}-W${week.toString().padStart(2, "0")}`;
+      break;
+    }
+    case "YYYY-[W]XX": {
+      const week = getISOWeek(now);
+      filename = `${now.getFullYear()}-[W]${week.toString().padStart(2, "0")}`;
+      break;
+    }
+    case "YYYY-MM":
+      filename = `${now.getFullYear()}-${(now.getMonth() + 1).toString().padStart(2, "0")}`;
+      break;
+    case "YYYY-QX": {
+      const quarter = Math.floor(now.getMonth() / 3) + 1;
+      filename = `${now.getFullYear()}-Q${quarter}`;
+      break;
+    }
+    case "YYYY":
+      filename = now.getFullYear().toString();
+      break;
+    default:
+      filename = now.toISOString().split("T")[0];
+  }
+  return `${folder}/${filename}.md`;
+}
+function getISOWeek(date) {
+  const target = new Date(date.valueOf());
+  const dayNr = (date.getDay() + 6) % 7;
+  target.setDate(target.getDate() - dayNr + 3);
+  const firstThursday = target.valueOf();
+  target.setMonth(0, 1);
+  if (target.getDay() !== 4) {
+    target.setMonth(0, 1 + (4 - target.getDay() + 7) % 7);
+  }
+  return 1 + Math.ceil((firstThursday - target.valueOf()) / 6048e5);
+}
+function detectPeriodicNotes(index, type) {
+  const patterns = DATE_PATTERNS[type];
+  const commonFolders = COMMON_FOLDERS[type];
+  const candidates = [];
+  const folderPatternCounts = /* @__PURE__ */ new Map();
+  const thirtyDaysAgo = /* @__PURE__ */ new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+  for (const note of index.notes.values()) {
+    const parts = note.path.split("/");
+    const filename = parts[parts.length - 1];
+    const folder = parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+    for (const patternDef of patterns) {
+      if (patternDef.regex.test(filename)) {
+        const key = `${folder}::${patternDef.format}`;
+        const existing = folderPatternCounts.get(key);
+        if (existing) {
+          existing.count++;
+          if (note.modified >= thirtyDaysAgo) {
+            existing.recentCount++;
+          }
+          existing.notes.push(note.path);
+        } else {
+          folderPatternCounts.set(key, {
+            pattern: patternDef.format,
+            count: 1,
+            recentCount: note.modified >= thirtyDaysAgo ? 1 : 0,
+            notes: [note.path]
+          });
+        }
+      }
+    }
+  }
+  for (const [key, data] of folderPatternCounts.entries()) {
+    const [folder, pattern] = key.split("::");
+    let score = Math.min(data.count / 30, 1) * 0.4;
+    score += Math.min(data.recentCount / 7, 1) * 0.3;
+    const folderName = folder.split("/").pop() || "";
+    if (commonFolders.some((cf) => folderName.toLowerCase() === cf.toLowerCase())) {
+      score += 0.2;
+    }
+    const folderNotes2 = Array.from(index.notes.values()).filter(
+      (n) => n.path.startsWith(folder + "/")
+    );
+    const consistency = folderNotes2.length > 0 ? data.count / folderNotes2.length : 0;
+    score += consistency * 0.1;
+    candidates.push({
+      folder: folder || ".",
+      pattern,
+      score
+    });
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  const best = candidates[0];
+  if (!best) {
+    return {
+      type,
+      detected: false,
+      folder: null,
+      pattern: null,
+      confidence: 0,
+      evidence: {
+        note_count: 0,
+        recent_notes: 0,
+        pattern_consistency: 0
+      },
+      today_path: null,
+      today_exists: false,
+      candidates: []
+    };
+  }
+  const bestData = folderPatternCounts.get(`${best.folder}::${best.pattern}`);
+  const folderNotes = Array.from(index.notes.values()).filter(
+    (n) => n.path.startsWith(best.folder === "." ? "" : best.folder + "/")
+  );
+  const patternConsistency = folderNotes.length > 0 ? bestData.count / folderNotes.length : 0;
+  const todayPath = getCurrentPeriodPath(type, best.folder, best.pattern);
+  const todayExists = index.notes.has(todayPath);
+  return {
+    type,
+    detected: true,
+    folder: best.folder,
+    pattern: best.pattern,
+    confidence: best.score,
+    evidence: {
+      note_count: bestData.count,
+      recent_notes: bestData.recentCount,
+      pattern_consistency: patternConsistency
+    },
+    today_path: todayPath,
+    today_exists: todayExists,
+    candidates: candidates.slice(0, 3)
+    // top 3
+  };
+}
+function registerPeriodicTools(server2, getIndex) {
+  const DetectPeriodicNotesOutputSchema = {
+    type: z7.string().describe("The type of periodic note (daily, weekly, etc.)"),
+    detected: z7.boolean().describe("Whether a pattern was detected"),
+    folder: z7.string().nullable().describe('Best-guess folder path (e.g., "daily-notes")'),
+    pattern: z7.string().nullable().describe('Best-guess filename pattern (e.g., "YYYY-MM-DD")'),
+    confidence: z7.number().describe("Confidence score 0-1"),
+    evidence: z7.object({
+      note_count: z7.number().describe("Number of notes matching pattern"),
+      recent_notes: z7.number().describe("Notes modified in last 30 days"),
+      pattern_consistency: z7.number().describe("Ratio of matching notes in folder")
+    }),
+    today_path: z7.string().nullable().describe("Path to today/current period note"),
+    today_exists: z7.boolean().describe("Whether today/current note exists"),
+    candidates: z7.array(
+      z7.object({
+        folder: z7.string(),
+        pattern: z7.string(),
+        score: z7.number()
+      })
+    ).describe("Top 3 candidate folder/pattern combinations")
+  };
+  server2.registerTool(
+    "detect_periodic_notes",
+    {
+      title: "Detect Periodic Note Conventions",
+      description: "Detect where the vault keeps periodic notes (daily, weekly, monthly, etc.) without user configuration. Returns best-guess folder, filename pattern, and path to today/current period note.",
+      inputSchema: {
+        type: z7.enum(["daily", "weekly", "monthly", "quarterly", "yearly"]).describe("Type of periodic note to detect")
+      },
+      outputSchema: DetectPeriodicNotesOutputSchema
+    },
+    async ({
+      type
+    }) => {
+      const index = getIndex();
+      const result = detectPeriodicNotes(index, type);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ],
+        structuredContent: result
+      };
+    }
+  );
+}
+
+// src/tools/bidirectional.ts
+import { z as z8 } from "zod";
+import * as fs9 from "fs/promises";
+import * as path7 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);
+  try {
+    return await fs9.readFile(fullPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function getBodyContent(content) {
+  try {
+    const parsed = matter2(content);
+    const frontmatterMatch = content.match(/^---\n[\s\S]*?\n---\n?/);
+    const bodyStartLine = frontmatterMatch ? frontmatterMatch[0].split("\n").length : 1;
+    return { body: parsed.content, bodyStartLine };
+  } catch {
+    return { body: content, bodyStartLine: 1 };
+  }
+}
+function removeCodeBlocks(content) {
+  return content.replace(CODE_BLOCK_REGEX2, (match) => {
+    const newlines = (match.match(/\n/g) || []).length;
+    return "\n".repeat(newlines);
+  });
+}
+function extractWikilinksFromValue(value) {
+  if (typeof value === "string") {
+    const matches = [];
+    let match;
+    WIKILINK_REGEX2.lastIndex = 0;
+    while ((match = WIKILINK_REGEX2.exec(value)) !== null) {
+      matches.push(match[1].trim());
+    }
+    return matches;
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((v) => extractWikilinksFromValue(v));
+  }
+  return [];
+}
+function isWikilinkValue(value) {
+  return /^\[\[.+\]\]$/.test(value.trim());
+}
+function normalizeRef(ref) {
+  return ref.toLowerCase().replace(/\.md$/, "").trim();
+}
+async function detectProsePatterns(index, notePath, vaultPath2) {
+  const content = await readFileContent(notePath, vaultPath2);
+  if (content === null) {
+    return {
+      path: notePath,
+      patterns: [],
+      error: "File not found"
+    };
+  }
+  const { body, bodyStartLine } = getBodyContent(content);
+  const cleanBody = removeCodeBlocks(body);
+  const patterns = [];
+  const lines = cleanBody.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = bodyStartLine + i;
+    if (!line.trim()) continue;
+    PROSE_PATTERN_REGEX.lastIndex = 0;
+    const match = PROSE_PATTERN_REGEX.exec(line);
+    if (match) {
+      const key = match[1].trim();
+      const wikilinkTarget = match[2]?.trim();
+      const quotedValue = match[3]?.trim();
+      const plainValue = match[4]?.trim();
+      const value = wikilinkTarget || quotedValue || plainValue;
+      if (value) {
+        patterns.push({
+          key,
+          value,
+          line: lineNumber,
+          raw: line.trim(),
+          isWikilink: !!wikilinkTarget
+        });
+      }
+    }
+  }
+  return {
+    path: notePath,
+    patterns
+  };
+}
+async function suggestFrontmatterFromProse(index, notePath, vaultPath2) {
+  const content = await readFileContent(notePath, vaultPath2);
+  if (content === null) {
+    return {
+      path: notePath,
+      suggestions: [],
+      error: "File not found"
+    };
+  }
+  let existingFrontmatter = {};
+  try {
+    existingFrontmatter = matter2(content).data;
+  } catch {
+  }
+  const { patterns } = await detectProsePatterns(index, notePath, vaultPath2);
+  const patternsByKey = /* @__PURE__ */ new Map();
+  for (const pattern of patterns) {
+    const keyLower = pattern.key.toLowerCase();
+    const existing = patternsByKey.get(keyLower);
+    if (existing) {
+      existing.patterns.push(pattern);
+    } else {
+      patternsByKey.set(keyLower, {
+        patterns: [pattern],
+        originalKey: pattern.key
+      });
+    }
+  }
+  const suggestions = [];
+  for (const [keyLower, { patterns: keyPatterns, originalKey }] of patternsByKey) {
+    const existingKey = Object.keys(existingFrontmatter).find(
+      (k) => k.toLowerCase() === keyLower
+    );
+    if (existingKey) continue;
+    const fieldName = originalKey.toLowerCase().replace(/\s+/g, "_").replace(/-/g, "_");
+    const values = keyPatterns.map((p) => {
+      if (p.isWikilink) {
+        return `[[${p.value}]]`;
+      }
+      return p.value;
+    });
+    const uniqueValues = [...new Set(values)];
+    const hasWikilink = keyPatterns.some((p) => p.isWikilink);
+    suggestions.push({
+      field: fieldName,
+      value: uniqueValues.length === 1 ? uniqueValues[0] : uniqueValues,
+      source_lines: keyPatterns.map((p) => p.line),
+      confidence: hasWikilink ? 0.9 : 0.7,
+      // Higher confidence for wikilink patterns
+      preserveWikilink: hasWikilink
+    });
+  }
+  return {
+    path: notePath,
+    suggestions
+  };
+}
+async function suggestWikilinksInFrontmatter(index, notePath, vaultPath2) {
+  const content = await readFileContent(notePath, vaultPath2);
+  if (content === null) {
+    return {
+      path: notePath,
+      suggestions: [],
+      error: "File not found"
+    };
+  }
+  let frontmatter = {};
+  try {
+    frontmatter = matter2(content).data;
+  } catch {
+    return {
+      path: notePath,
+      suggestions: [],
+      error: "Invalid frontmatter"
+    };
+  }
+  const suggestions = [];
+  function checkValue(field, value, arrayIndex) {
+    if (typeof value !== "string") return;
+    if (isWikilinkValue(value)) return;
+    if (!value.trim()) return;
+    const normalizedValue = normalizeRef(value);
+    const matchedPath = index.entities.get(normalizedValue);
+    if (matchedPath) {
+      const targetNote = index.notes.get(matchedPath);
+      suggestions.push({
+        field,
+        current_value: value,
+        suggested_link: `[[${targetNote?.title || value}]]`,
+        target_note: matchedPath,
+        array_index: arrayIndex
+      });
+    }
+  }
+  for (const [field, value] of Object.entries(frontmatter)) {
+    if (Array.isArray(value)) {
+      value.forEach((v, i) => checkValue(field, v, i));
+    } else {
+      checkValue(field, value);
+    }
+  }
+  return {
+    path: notePath,
+    suggestions
+  };
+}
+async function validateCrossLayer(index, notePath, vaultPath2) {
+  const content = await readFileContent(notePath, vaultPath2);
+  if (content === null) {
+    return {
+      path: notePath,
+      frontmatter_only: [],
+      prose_only: [],
+      consistent: [],
+      error: "File not found"
+    };
+  }
+  let frontmatter = {};
+  let body = content;
+  try {
+    const parsed = matter2(content);
+    frontmatter = parsed.data;
+    body = parsed.content;
+  } catch {
+  }
+  const frontmatterRefs = /* @__PURE__ */ new Map();
+  for (const [field, value] of Object.entries(frontmatter)) {
+    const wikilinks = extractWikilinksFromValue(value);
+    for (const target of wikilinks) {
+      frontmatterRefs.set(normalizeRef(target), { field, target });
+    }
+    if (typeof value === "string" && !isWikilinkValue(value)) {
+      const normalized = normalizeRef(value);
+      if (index.entities.has(normalized)) {
+        frontmatterRefs.set(normalized, { field, target: value });
+      }
+    }
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        if (typeof v === "string" && !isWikilinkValue(v)) {
+          const normalized = normalizeRef(v);
+          if (index.entities.has(normalized)) {
+            frontmatterRefs.set(normalized, { field, target: v });
+          }
+        }
+      }
+    }
+  }
+  const proseRefs = /* @__PURE__ */ new Map();
+  const cleanBody = removeCodeBlocks(body);
+  const lines = cleanBody.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    WIKILINK_REGEX2.lastIndex = 0;
+    let match;
+    while ((match = WIKILINK_REGEX2.exec(line)) !== null) {
+      const target = match[1].trim();
+      proseRefs.set(normalizeRef(target), { line: i + 1, target });
+    }
+  }
+  const frontmatter_only = [];
+  const prose_only = [];
+  const consistent = [];
+  for (const [normalized, { field, target }] of frontmatterRefs) {
+    if (proseRefs.has(normalized)) {
+      consistent.push({ field, target });
+    } else {
+      frontmatter_only.push({ field, target });
+    }
+  }
+  for (const [normalized, { line, target }] of proseRefs) {
+    if (!frontmatterRefs.has(normalized)) {
+      prose_only.push({ pattern: `[[${target}]]`, target, line });
+    }
+  }
+  return {
+    path: notePath,
+    frontmatter_only,
+    prose_only,
+    consistent
+  };
+}
+function registerBidirectionalTools(server2, getIndex, getVaultPath) {
+  server2.registerTool(
+    "detect_prose_patterns",
+    {
+      title: "Detect Prose Patterns",
+      description: 'Find "Key: [[Value]]" or "Key: Value" patterns in note prose (not frontmatter). Useful for identifying implicit metadata.',
+      inputSchema: {
+        path: z8.string().describe('Path to the note (e.g., "daily/2024-01-15.md")')
+      }
+    },
+    async ({ path: notePath }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await detectProsePatterns(index, notePath, vaultPath2);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "suggest_frontmatter_from_prose",
+    {
+      title: "Suggest Frontmatter From Prose",
+      description: "Analyze prose patterns and suggest YAML frontmatter additions. Groups repeated patterns and preserves wikilinks.",
+      inputSchema: {
+        path: z8.string().describe("Path to the note")
+      }
+    },
+    async ({ path: notePath }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await suggestFrontmatterFromProse(index, notePath, vaultPath2);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "suggest_wikilinks_in_frontmatter",
+    {
+      title: "Suggest Wikilinks in Frontmatter",
+      description: "Find frontmatter string values that match existing note titles or aliases, and suggest converting them to wikilinks.",
+      inputSchema: {
+        path: z8.string().describe("Path to the note")
+      }
+    },
+    async ({ path: notePath }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await suggestWikilinksInFrontmatter(
+        index,
+        notePath,
+        vaultPath2
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "validate_cross_layer",
+    {
+      title: "Validate Cross Layer",
+      description: "Check consistency between frontmatter references and prose wikilinks. Identifies references that appear in only one layer.",
+      inputSchema: {
+        path: z8.string().describe("Path to the note")
+      }
+    },
+    async ({ path: notePath }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await validateCrossLayer(index, notePath, vaultPath2);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/schema.ts
+import { z as z9 } from "zod";
+function getValueType2(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) {
+    if (value.some((v) => typeof v === "string" && /^\[\[.+\]\]$/.test(v))) {
+      return "wikilink[]";
+    }
+    return "array";
+  }
+  if (typeof value === "string") {
+    if (/^\[\[.+\]\]$/.test(value)) return "wikilink";
+    if (/^\d{4}-\d{2}-\d{2}/.test(value)) return "date";
+  }
+  if (value instanceof Date) return "date";
+  return typeof value;
+}
+function getFolder(notePath) {
+  const lastSlash = notePath.lastIndexOf("/");
+  return lastSlash === -1 ? "" : notePath.substring(0, lastSlash);
+}
+function getNotesInFolder(index, folder) {
+  const notes = [];
+  for (const note of index.notes.values()) {
+    if (!folder || note.path.startsWith(folder + "/") || getFolder(note.path) === folder) {
+      notes.push(note);
+    }
+  }
+  return notes;
+}
+function detectNamingPattern(notes) {
+  if (notes.length < 3) return null;
+  const filenames = notes.map((n) => {
+    const lastSlash = n.path.lastIndexOf("/");
+    return lastSlash === -1 ? n.path : n.path.substring(lastSlash + 1);
+  });
+  const datePattern = /^\d{4}-\d{2}-\d{2}/;
+  const dateMatches = filenames.filter((f) => datePattern.test(f));
+  if (dateMatches.length / filenames.length > 0.8) {
+    const suffixes = dateMatches.map((f) => f.replace(/^\d{4}-\d{2}-\d{2}/, ""));
+    const uniqueSuffixes = new Set(suffixes);
+    if (uniqueSuffixes.size === 1) {
+      return `YYYY-MM-DD${Array.from(uniqueSuffixes)[0]}`;
+    }
+    return "YYYY-MM-DD *.md";
+  }
+  const prefixPattern = /^([A-Z]+-)\d+/;
+  const prefixMatches = filenames.filter((f) => prefixPattern.test(f));
+  if (prefixMatches.length / filenames.length > 0.8) {
+    const match = filenames[0].match(prefixPattern);
+    if (match) {
+      return `${match[1]}### *.md`;
+    }
+  }
+  return null;
+}
+function inferFolderConventions(index, folder, minConfidence = 0.5) {
+  const notes = getNotesInFolder(index, folder);
+  const totalNotes = notes.length;
+  if (totalNotes === 0) {
+    return {
+      folder: folder || "(vault root)",
+      note_count: 0,
+      coverage: 0,
+      inferred_fields: [],
+      computed_field_suggestions: [],
+      naming_pattern: null
+    };
+  }
+  const notesWithFrontmatter = notes.filter(
+    (n) => n.frontmatter && Object.keys(n.frontmatter).length > 0
+  );
+  const coverage = notesWithFrontmatter.length / totalNotes;
+  const fieldStats = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    for (const [key, value] of Object.entries(note.frontmatter)) {
+      if (!fieldStats.has(key)) {
+        fieldStats.set(key, {
+          count: 0,
+          types: /* @__PURE__ */ new Map(),
+          values: /* @__PURE__ */ new Map(),
+          examples: []
+        });
+      }
+      const stats = fieldStats.get(key);
+      stats.count++;
+      const type = getValueType2(value);
+      stats.types.set(type, (stats.types.get(type) || 0) + 1);
+      const valueStr = JSON.stringify(value);
+      stats.values.set(valueStr, (stats.values.get(valueStr) || 0) + 1);
+      if (stats.examples.length < 3) {
+        stats.examples.push(note.path);
+      }
+    }
+  }
+  const inferredFields = [];
+  for (const [name, stats] of fieldStats) {
+    const frequency = stats.count / totalNotes;
+    if (frequency < minConfidence) continue;
+    let primaryType = "string";
+    let maxTypeCount = 0;
+    for (const [type, count] of stats.types) {
+      if (count > maxTypeCount) {
+        maxTypeCount = count;
+        primaryType = type;
+      }
+    }
+    const uniqueValues = stats.values.size;
+    const isEnumerable = uniqueValues <= 20 && uniqueValues / stats.count < 0.5;
+    let commonValues = null;
+    if (isEnumerable) {
+      const sortedValues = Array.from(stats.values.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10);
+      commonValues = sortedValues.map(([v]) => JSON.parse(v));
+    }
+    const typeConsistency = maxTypeCount / stats.count;
+    const confidence = Math.min(1, frequency * typeConsistency);
+    inferredFields.push({
+      name,
+      frequency,
+      inferred_type: primaryType,
+      is_required: frequency >= 0.9,
+      common_values: commonValues,
+      example_notes: stats.examples,
+      confidence
+    });
+  }
+  inferredFields.sort((a, b) => b.frequency - a.frequency);
+  const computedSuggestions = [];
+  const hasWordCount = fieldStats.has("word_count");
+  if (!hasWordCount && notes.length > 5) {
+    computedSuggestions.push({
+      name: "word_count",
+      description: "Number of words in note body",
+      sample_value: 500
+    });
+  }
+  const hasLinkCount = fieldStats.has("link_count");
+  if (!hasLinkCount && notes.some((n) => n.outlinks.length > 0)) {
+    computedSuggestions.push({
+      name: "link_count",
+      description: "Number of outgoing wikilinks",
+      sample_value: notes[0]?.outlinks.length || 0
+    });
+  }
+  const namingPattern = detectNamingPattern(notes);
+  return {
+    folder: folder || "(vault root)",
+    note_count: totalNotes,
+    coverage,
+    inferred_fields: inferredFields,
+    computed_field_suggestions: computedSuggestions,
+    naming_pattern: namingPattern
+  };
+}
+function findIncompleteNotes(index, folder, minFrequency = 0.7, limit = 50, offset = 0) {
+  const conventions = inferFolderConventions(index, folder, minFrequency);
+  const notes = getNotesInFolder(index, folder);
+  const expectedFields = conventions.inferred_fields.filter(
+    (f) => f.frequency >= minFrequency
+  );
+  if (expectedFields.length === 0) {
+    return {
+      folder: folder || null,
+      total_notes: notes.length,
+      incomplete_count: 0,
+      notes: []
+    };
+  }
+  const incompleteNotes = [];
+  for (const note of notes) {
+    const existingFields = Object.keys(note.frontmatter);
+    const missingFields = [];
+    for (const expected of expectedFields) {
+      if (!existingFields.includes(expected.name)) {
+        let suggestedValue = null;
+        let suggestionSource = null;
+        if (expected.common_values && expected.common_values.length > 0) {
+          suggestedValue = expected.common_values[0];
+          suggestionSource = "similar_notes";
+        }
+        missingFields.push({
+          name: expected.name,
+          expected_type: expected.inferred_type,
+          frequency_in_folder: expected.frequency,
+          suggested_value: suggestedValue,
+          suggestion_source: suggestionSource
+        });
+      }
+    }
+    if (missingFields.length > 0) {
+      const completeness = 1 - missingFields.length / expectedFields.length;
+      incompleteNotes.push({
+        path: note.path,
+        existing_fields: existingFields,
+        missing_fields: missingFields,
+        completeness_score: Math.round(completeness * 100) / 100
+      });
+    }
+  }
+  incompleteNotes.sort((a, b) => a.completeness_score - b.completeness_score);
+  const paginatedNotes = incompleteNotes.slice(offset, offset + limit);
+  return {
+    folder: folder || null,
+    total_notes: notes.length,
+    incomplete_count: incompleteNotes.length,
+    notes: paginatedNotes
+  };
+}
+function suggestFieldValues(index, field, context) {
+  const notes = context?.folder ? getNotesInFolder(index, context.folder) : Array.from(index.notes.values());
+  const valueStats = /* @__PURE__ */ new Map();
+  let totalWithField = 0;
+  let primaryType = "string";
+  const typeCounts = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    const value = note.frontmatter[field];
+    if (value === void 0) continue;
+    totalWithField++;
+    const type = getValueType2(value);
+    typeCounts.set(type, (typeCounts.get(type) || 0) + 1);
+    const values = Array.isArray(value) ? value : [value];
+    for (const v of values) {
+      const key = JSON.stringify(v);
+      if (!valueStats.has(key)) {
+        valueStats.set(key, {
+          value: v,
+          count: 0,
+          notes: []
+        });
+      }
+      const stats = valueStats.get(key);
+      stats.count++;
+      if (stats.notes.length < 3) {
+        stats.notes.push(note.path);
+      }
+    }
+  }
+  let maxTypeCount = 0;
+  for (const [type, count] of typeCounts) {
+    if (count > maxTypeCount) {
+      maxTypeCount = count;
+      primaryType = type;
+    }
+  }
+  const suggestions = Array.from(valueStats.values()).map((stats) => {
+    const frequency = stats.count / totalWithField;
+    let confidence = frequency;
+    let reason = `Used ${stats.count} times (${Math.round(frequency * 100)}%)`;
+    if (context?.existing_frontmatter) {
+      for (const notePath of stats.notes) {
+        const note = index.notes.get(notePath);
+        if (!note) continue;
+        for (const [key, value] of Object.entries(context.existing_frontmatter)) {
+          if (key !== field && JSON.stringify(note.frontmatter[key]) === JSON.stringify(value)) {
+            confidence = Math.min(1, confidence + 0.1);
+            reason = `Common when ${key}=${JSON.stringify(value)}`;
+            break;
+          }
+        }
+      }
+    }
+    return {
+      value: stats.value,
+      frequency,
+      confidence,
+      reason,
+      example_notes: stats.notes
+    };
+  }).sort((a, b) => b.confidence - a.confidence).slice(0, 10);
+  const isEnumerable = valueStats.size <= 20;
+  return {
+    field,
+    suggestions,
+    value_type: primaryType,
+    is_enumerable: isEnumerable
+  };
+}
+function registerSchemaTools(server2, getIndex, getVaultPath) {
+  server2.registerTool(
+    "infer_folder_conventions",
+    {
+      title: "Infer Folder Conventions",
+      description: "Auto-detect metadata conventions for a folder. Analyzes field frequency, types, common values, and naming patterns. Returns inferred schema with confidence scores.",
+      inputSchema: {
+        folder: z9.string().optional().describe('Folder to analyze (e.g., "meetings/"). If omitted, analyzes entire vault.'),
+        min_confidence: z9.number().min(0).max(1).optional().describe("Minimum confidence threshold (0.0-1.0). Default 0.5.")
+      }
+    },
+    async ({ folder, min_confidence }) => {
+      const index = getIndex();
+      const result = inferFolderConventions(
+        index,
+        folder,
+        min_confidence ?? 0.5
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "find_incomplete_notes",
+    {
+      title: "Find Incomplete Notes",
+      description: "Find notes missing expected fields based on inferred folder conventions. Returns completeness scores and suggested values.",
+      inputSchema: {
+        folder: z9.string().optional().describe("Folder to analyze. If omitted, analyzes entire vault."),
+        min_frequency: z9.number().min(0).max(1).optional().describe('Minimum field frequency to consider "expected" (default 0.7).'),
+        limit: z9.number().optional().describe("Maximum results to return (default 50)."),
+        offset: z9.number().optional().describe("Number of results to skip for pagination (default 0).")
+      }
+    },
+    async ({ folder, min_frequency, limit: requestedLimit, offset }) => {
+      const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
+      const index = getIndex();
+      const result = findIncompleteNotes(
+        index,
+        folder,
+        min_frequency ?? 0.7,
+        limit,
+        offset ?? 0
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "suggest_field_values",
+    {
+      title: "Suggest Field Values",
+      description: "Suggest appropriate values for a frontmatter field based on vault usage. Context-aware suggestions based on folder and existing fields.",
+      inputSchema: {
+        field: z9.string().describe("Field name to get suggestions for"),
+        folder: z9.string().optional().describe("Limit suggestions to this folder"),
+        existing_frontmatter: z9.record(z9.unknown()).optional().describe("Other frontmatter fields in the note for context")
+      }
+    },
+    async ({ field, folder, existing_frontmatter }) => {
+      const index = getIndex();
+      const result = suggestFieldValues(index, field, {
+        folder,
+        existing_frontmatter
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/computed.ts
+import { z as z10 } from "zod";
+import * as fs10 from "fs/promises";
+import * as path8 from "path";
+import matter3 from "gray-matter";
+async function readFileContent2(notePath, vaultPath2) {
+  const fullPath = path8.join(vaultPath2, notePath);
+  try {
+    return await fs10.readFile(fullPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function getFileStats(notePath, vaultPath2) {
+  const fullPath = path8.join(vaultPath2, notePath);
+  try {
+    const stats = await fs10.stat(fullPath);
+    return {
+      modified: stats.mtime,
+      created: stats.birthtime
+    };
+  } catch {
+    return null;
+  }
+}
+function countWords(text) {
+  let clean = text.replace(/```[\s\S]*?```/g, "");
+  clean = clean.replace(/`[^`\n]+`/g, "");
+  clean = clean.replace(/\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g, (_, target, alias) => alias || target);
+  clean = clean.replace(/[#*_~`]/g, "");
+  const words = clean.split(/\s+/).filter((w) => w.length > 0);
+  return words.length;
+}
+function formatDate(date) {
+  return date.toISOString().split("T")[0];
+}
+function calculateReadingTime(wordCount) {
+  const minutes = Math.ceil(wordCount / 200);
+  return `${minutes} min`;
+}
+var COMPUTABLE_FIELDS = [
+  "word_count",
+  "link_count",
+  "backlink_count",
+  "tag_count",
+  "reading_time",
+  "created",
+  "last_updated"
+];
+async function computeFrontmatter(index, notePath, vaultPath2, fields) {
+  const content = await readFileContent2(notePath, vaultPath2);
+  if (content === null) {
+    return {
+      path: notePath,
+      computed: [],
+      suggested_additions: {},
+      error: "File not found"
+    };
+  }
+  let existingFrontmatter = {};
+  let body = content;
+  try {
+    const parsed = matter3(content);
+    existingFrontmatter = parsed.data;
+    body = parsed.content;
+  } catch {
+  }
+  const note = index.notes.get(notePath);
+  const stats = await getFileStats(notePath, vaultPath2);
+  const fieldsToCompute = fields ? fields.filter((f) => COMPUTABLE_FIELDS.includes(f)) : [...COMPUTABLE_FIELDS];
+  const computed = [];
+  const suggestedAdditions = {};
+  for (const fieldName of fieldsToCompute) {
+    let value = null;
+    let method = "";
+    switch (fieldName) {
+      case "word_count": {
+        value = countWords(body);
+        method = "prose_word_count";
+        break;
+      }
+      case "link_count": {
+        value = note?.outlinks.length ?? 0;
+        method = "outlink_count";
+        break;
+      }
+      case "backlink_count": {
+        const backlinks = index.backlinks.get(note?.title.toLowerCase() ?? "");
+        value = backlinks?.length ?? 0;
+        method = "backlink_index";
+        break;
+      }
+      case "tag_count": {
+        value = note?.tags.length ?? 0;
+        method = "tag_count";
+        break;
+      }
+      case "reading_time": {
+        const words = countWords(body);
+        value = calculateReadingTime(words);
+        method = "word_count / 200";
+        break;
+      }
+      case "created": {
+        if (stats?.created) {
+          value = formatDate(stats.created);
+          method = "file_birthtime";
+        }
+        break;
+      }
+      case "last_updated": {
+        if (stats?.modified) {
+          value = formatDate(stats.modified);
+          method = "file_mtime";
+        }
+        break;
+      }
+    }
+    if (value !== null) {
+      const existingValue = existingFrontmatter[fieldName];
+      const alreadyExists = existingValue !== void 0;
+      let differs = null;
+      if (alreadyExists) {
+        differs = JSON.stringify(existingValue) !== JSON.stringify(value);
+      }
+      computed.push({
+        name: fieldName,
+        value,
+        method,
+        already_exists: alreadyExists,
+        differs
+      });
+      if (!alreadyExists) {
+        suggestedAdditions[fieldName] = value;
+      }
+    }
+  }
+  return {
+    path: notePath,
+    computed,
+    suggested_additions: suggestedAdditions
+  };
+}
+function registerComputedTools(server2, getIndex, getVaultPath) {
+  server2.registerTool(
+    "compute_frontmatter",
+    {
+      title: "Compute Frontmatter",
+      description: "Auto-compute derived fields from note content. Computes: word_count, link_count, backlink_count, tag_count, reading_time, created, last_updated.",
+      inputSchema: {
+        path: z10.string().describe("Path to the note"),
+        fields: z10.array(z10.string()).optional().describe("Specific fields to compute. If omitted, computes all available fields.")
+      }
+    },
+    async ({ path: notePath, fields }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await computeFrontmatter(index, notePath, vaultPath2, fields);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/migrations.ts
+import { z as z11 } from "zod";
+import * as fs11 from "fs/promises";
+import * as path9 from "path";
+import matter4 from "gray-matter";
+function getNotesInFolder2(index, folder) {
+  const notes = [];
+  for (const note of index.notes.values()) {
+    const noteFolder = note.path.includes("/") ? note.path.substring(0, note.path.lastIndexOf("/")) : "";
+    if (!folder || note.path.startsWith(folder + "/") || noteFolder === folder) {
+      notes.push(note);
+    }
+  }
+  return notes;
+}
+async function readFileContent3(notePath, vaultPath2) {
+  const fullPath = path9.join(vaultPath2, notePath);
+  try {
+    return await fs11.readFile(fullPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeFileContent(notePath, vaultPath2, content) {
+  const fullPath = path9.join(vaultPath2, notePath);
+  try {
+    await fs11.writeFile(fullPath, content, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function updateFrontmatter(notePath, vaultPath2, updateFn) {
+  const content = await readFileContent3(notePath, vaultPath2);
+  if (content === null) return false;
+  try {
+    const parsed = matter4(content);
+    const newFrontmatter = updateFn(parsed.data);
+    const newContent = matter4.stringify(parsed.content, newFrontmatter);
+    return await writeFileContent(notePath, vaultPath2, newContent);
+  } catch {
+    return false;
+  }
+}
+async function renameField(index, vaultPath2, oldName, newName, options) {
+  const dryRun = options?.dry_run ?? true;
+  const notes = getNotesInFolder2(index, options?.folder);
+  const previews = [];
+  let conflicts = 0;
+  for (const note of notes) {
+    const oldValue = note.frontmatter[oldName];
+    if (oldValue === void 0) continue;
+    const hasNewField = note.frontmatter[newName] !== void 0;
+    if (hasNewField) {
+      previews.push({
+        path: note.path,
+        old_value: oldValue,
+        status: "conflict"
+      });
+      conflicts++;
+      continue;
+    }
+    if (dryRun) {
+      previews.push({
+        path: note.path,
+        old_value: oldValue,
+        status: "pending"
+      });
+    } else {
+      const success = await updateFrontmatter(note.path, vaultPath2, (fm) => {
+        const newFm = { ...fm };
+        delete newFm[oldName];
+        newFm[newName] = oldValue;
+        return newFm;
+      });
+      previews.push({
+        path: note.path,
+        old_value: oldValue,
+        status: success ? "applied" : "pending"
+      });
+    }
+  }
+  return {
+    old_name: oldName,
+    new_name: newName,
+    dry_run: dryRun,
+    affected_notes: previews.length,
+    notes: previews,
+    conflicts
+  };
+}
+async function migrateFieldValues(index, vaultPath2, field, mapping, options) {
+  const dryRun = options?.dry_run ?? true;
+  const notes = getNotesInFolder2(index, options?.folder);
+  const previews = [];
+  let migrated = 0;
+  let unchanged = 0;
+  for (const note of notes) {
+    const currentValue = note.frontmatter[field];
+    if (currentValue === void 0) continue;
+    const currentKey = String(currentValue);
+    const newValue = mapping[currentKey];
+    if (newValue === void 0) {
+      previews.push({
+        path: note.path,
+        old_value: currentValue,
+        new_value: currentValue,
+        status: "no_match"
+      });
+      unchanged++;
+      continue;
+    }
+    if (dryRun) {
+      previews.push({
+        path: note.path,
+        old_value: currentValue,
+        new_value: newValue,
+        status: "pending"
+      });
+      migrated++;
+    } else {
+      const success = await updateFrontmatter(note.path, vaultPath2, (fm) => {
+        return { ...fm, [field]: newValue };
+      });
+      previews.push({
+        path: note.path,
+        old_value: currentValue,
+        new_value: newValue,
+        status: success ? "applied" : "pending"
+      });
+      if (success) migrated++;
+    }
+  }
+  return {
+    field,
+    dry_run: dryRun,
+    total_notes: notes.filter((n) => n.frontmatter[field] !== void 0).length,
+    migrated,
+    unchanged,
+    previews
+  };
+}
+function registerMigrationTools(server2, getIndex, getVaultPath) {
+  server2.registerTool(
+    "rename_field",
+    {
+      title: "Rename Field",
+      description: "Bulk rename a frontmatter field across notes. Dry-run by default (preview only). Detects conflicts where new field name already exists.",
+      inputSchema: {
+        old_name: z11.string().describe("Current field name to rename"),
+        new_name: z11.string().describe("New field name"),
+        folder: z11.string().optional().describe("Limit to notes in this folder"),
+        dry_run: z11.boolean().optional().describe("Preview only, no changes (default: true)")
+      }
+    },
+    async ({ old_name, new_name, folder, dry_run }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await renameField(index, vaultPath2, old_name, new_name, {
+        folder,
+        dry_run: dry_run ?? true
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "migrate_field_values",
+    {
+      title: "Migrate Field Values",
+      description: 'Transform field values in bulk using a mapping (e.g., "high" -> 1). Dry-run by default.',
+      inputSchema: {
+        field: z11.string().describe("Field to migrate values for"),
+        mapping: z11.record(z11.unknown()).describe('Mapping of old values to new values (e.g., {"high": 1, "medium": 2, "low": 3})'),
+        folder: z11.string().optional().describe("Limit to notes in this folder"),
+        dry_run: z11.boolean().optional().describe("Preview only, no changes (default: true)")
+      }
+    },
+    async ({ field, mapping, folder, dry_run }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await migrateFieldValues(index, vaultPath2, field, mapping, {
+        folder,
+        dry_run: dry_run ?? true
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/core/vaultRoot.ts
+import * as fs12 from "fs";
+import * as path10 from "path";
+var VAULT_MARKERS = [".obsidian", ".claude"];
+function findVaultRoot(startPath) {
+  let current = path10.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()) {
+        return current;
+      }
+    }
+    const parent = path10.dirname(current);
+    if (parent === current) {
+      return startPath || process.cwd();
+    }
+    current = parent;
+  }
+}
+
+// src/index.ts
+var vaultPath = process.env.PROJECT_PATH || findVaultRoot();
+var flywheelConfig = {};
+var vaultIndex;
+var server = new McpServer({
+  name: "flywheel",
+  version: "1.7.0"
+});
+registerGraphTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerWikilinkTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerHealthTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerQueryTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerSystemTools(
+  server,
+  () => vaultIndex,
+  (newIndex) => {
+    vaultIndex = newIndex;
+  },
+  () => vaultPath,
+  (newConfig) => {
+    flywheelConfig = newConfig;
+  }
+);
+registerPrimitiveTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath,
+  () => flywheelConfig
+);
+registerPeriodicTools(
+  server,
+  () => vaultIndex
+);
+registerBidirectionalTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerSchemaTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerComputedTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerMigrationTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Flywheel MCP server running on stdio");
+  console.error("Building vault index in background...");
+  const startTime = Date.now();
+  buildVaultIndex(vaultPath).then((index) => {
+    vaultIndex = index;
+    setIndexState("ready");
+    const duration = Date.now() - startTime;
+    console.error(`Vault index ready in ${duration}ms`);
+    const existing = loadConfig(vaultPath);
+    const inferred = inferConfig(vaultIndex, vaultPath);
+    saveConfig(vaultPath, inferred, existing);
+    flywheelConfig = loadConfig(vaultPath);
+    if (flywheelConfig.vault_name) {
+      console.error(`[Flywheel] Vault: ${flywheelConfig.vault_name}`);
+    }
+    if (flywheelConfig.paths) {
+      const detectedPaths = Object.entries(flywheelConfig.paths).filter(([, v]) => v).map(([k, v]) => `${k}: ${v}`);
+      if (detectedPaths.length) {
+        console.error(`[Flywheel] Detected paths: ${detectedPaths.join(", ")}`);
+      }
+    }
+    if (flywheelConfig.exclude_task_tags?.length) {
+      console.error(`[Flywheel] Excluding task tags: ${flywheelConfig.exclude_task_tags.join(", ")}`);
+    }
+  }).catch((err) => {
+    setIndexState("error");
+    setIndexError(err instanceof Error ? err : new Error(String(err)));
+    console.error("Failed to build vault index:", err);
+  });
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});