smoking-mirror 1.0.0

package/dist/index.js

@@ -0,0 +1,1196 @@
+#!/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"
+]);
+async function scanVault(vaultPath2) {
+  const files = [];
+  async function scan(dir, relativePath = "") {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    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;
+        }
+        await scan(fullPath, relPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        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;
+function normalizeTarget(target) {
+  return target.toLowerCase().replace(/\.md$/, "");
+}
+function normalizeNotePath(path3) {
+  return path3.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`);
+  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++;
+    }
+    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
+  };
+}
+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);
+}
+
+// src/tools/graph.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+import { z } from "zod";
+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"),
+  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")
+      },
+      outputSchema: GetBacklinksOutputSchema
+    },
+    async ({ path: notePath, include_context }) => {
+      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 backlinks = getBacklinksForNote(index, resolvedPath);
+      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: 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 }) => {
+      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"),
+    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/")')
+      },
+      outputSchema: FindOrphansOutputSchema
+    },
+    async ({ folder }) => {
+      const index = getIndex();
+      const orphans = findOrphanNotes(index, folder);
+      const output = {
+        orphan_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"),
+    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")
+      },
+      outputSchema: FindHubsOutputSchema
+    },
+    async ({ min_links }) => {
+      const index = getIndex();
+      const hubs = findHubNotes(index, min_links);
+      const output = {
+        hub_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("Number of suggestions found"),
+    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")
+      },
+      outputSchema: SuggestWikilinksOutputSchema
+    },
+    async ({ text }) => {
+      const index = getIndex();
+      const matches = findEntityMatches(text, index.entities);
+      const output = {
+        input_length: text.length,
+        suggestion_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("Number of broken links"),
+    broken: z2.array(BrokenLinkSchema).describe("List of broken links")
+  };
+  function findSimilarEntity(target, entities) {
+    const targetLower = target.toLowerCase();
+    for (const [name, path3] of entities) {
+      if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
+        return path3;
+      }
+    }
+    for (const [name, path3] of entities) {
+      if (name.includes(targetLower) || targetLower.includes(name)) {
+        return path3;
+      }
+    }
+    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.")
+      },
+      outputSchema: ValidateLinksOutputSchema
+    },
+    async ({ path: notePath }) => {
+      const index = getIndex();
+      const broken = [];
+      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 = findSimilarEntity(link.target, index.entities);
+            broken.push({
+              source: sourcePath,
+              target: link.target,
+              line: link.line,
+              suggestion
+            });
+          }
+        }
+      }
+      const output = {
+        scope: notePath || "all",
+        total_links: totalLinks,
+        valid_links: validLinks,
+        broken_links: broken.length,
+        broken
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ],
+        structuredContent: output
+      };
+    }
+  );
+}
+
+// src/tools/health.ts
+import { z as z3 } from "zod";
+function registerHealthTools(server2, getIndex, getVaultPath) {
+  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")
+  });
+  const FindBrokenLinksOutputSchema = {
+    scope: z3.string().describe('Folder searched, or "all" for entire vault'),
+    broken_count: z3.number().describe("Number of broken links found"),
+    affected_notes: z3.number().describe("Number of notes with broken links"),
+    broken_links: z3.array(BrokenLinkSchema).describe("List of broken links")
+  };
+  server2.registerTool(
+    "find_broken_links",
+    {
+      title: "Find Broken Links",
+      description: "Find all wikilinks that point to non-existent notes. Useful for vault maintenance.",
+      inputSchema: {
+        folder: z3.string().optional().describe('Limit search to a specific folder (e.g., "daily-notes/")')
+      },
+      outputSchema: FindBrokenLinksOutputSchema
+    },
+    async ({ folder }) => {
+      const index = getIndex();
+      const brokenLinks = [];
+      const affectedNotes = /* @__PURE__ */ new Set();
+      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) {
+            brokenLinks.push({
+              source: note.path,
+              target: link.target,
+              line: link.line
+            });
+            affectedNotes.add(note.path);
+          }
+        }
+      }
+      brokenLinks.sort((a, b) => {
+        const pathCompare = a.source.localeCompare(b.source);
+        if (pathCompare !== 0) return pathCompare;
+        return a.line - b.line;
+      });
+      const output = {
+        scope: folder || "all",
+        broken_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 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: z3.number().describe("Notes with no backlinks"),
+    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")
+  };
+  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 orphanNotes = 0;
+      for (const note of index.notes.values()) {
+        totalLinks += note.outlinks.length;
+        for (const link of note.outlinks) {
+          if (!resolveTarget(index, link.target)) {
+            brokenLinks++;
+          }
+        }
+      }
+      for (const note of index.notes.values()) {
+        const backlinks = getBacklinksForNote(index, note.path);
+        if (backlinks.length === 0) {
+          orphanNotes++;
+        }
+      }
+      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: orphanNotes,
+        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 = 50
+    }) => {
+      const index = getIndex();
+      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/index.ts
+var VAULT_PATH = process.env.OBSIDIAN_VAULT_PATH;
+if (!VAULT_PATH) {
+  console.error("Error: OBSIDIAN_VAULT_PATH environment variable is required");
+  process.exit(1);
+}
+var vaultPath = VAULT_PATH;
+var vaultIndex;
+var server = new McpServer({
+  name: "smoking-mirror",
+  version: "1.0.0"
+});
+registerGraphTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerWikilinkTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerHealthTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+registerQueryTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
+async function main() {
+  console.error("Building vault index...");
+  const startTime = Date.now();
+  try {
+    vaultIndex = await buildVaultIndex(vaultPath);
+    const duration = Date.now() - startTime;
+    console.error(`Vault index built in ${duration}ms`);
+  } catch (err) {
+    console.error("Failed to build vault index:", err);
+    process.exit(1);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("smoking-mirror MCP server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});