smoking-mirror 1.0.0 → 1.2.0

package/dist/index.js

@@ -212,8 +212,8 @@ var PROGRESS_INTERVAL = 100;
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path3) {
-  return path3.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path6) {
+  return path6.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -717,14 +717,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path3] of entities) {
+    for (const [name, path6] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path3;
+        return path6;
       }
     }
-    for (const [name, path3] of entities) {
+    for (const [name, path6] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path3;
+        return path6;
       }
     }
     return void 0;
@@ -1143,6 +1143,1615 @@ function registerQueryTools(server2, getIndex, getVaultPath) {
   );
 }
 
+// src/tools/system.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+import { z as z5 } from "zod";
+function registerSystemTools(server2, getIndex, setIndex, getVaultPath) {
+  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();
+      try {
+        const newIndex = await buildVaultIndex(vaultPath2);
+        setIndex(newIndex);
+        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) {
+        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
+    }) => {
+      const index = getIndex();
+      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 = limit ? entities.slice(0, limit) : entities;
+      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,
+      folder
+    }) => {
+      const index = getIndex();
+      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
+    }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      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 = path3.join(vaultPath2, note.path);
+          const content = await fs4.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
+    }) => {
+      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 = path3.join(vaultPath2, resolvedPath);
+          const content = await fs4.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 () => {
+      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, path6, hours = 24) {
+  const targetNote = index.notes.get(path6);
+  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 === path6) 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 fs5 from "fs";
+import * as path4 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 = path4.join(vaultPath2, notePath);
+  let content;
+  try {
+    content = await fs5.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 = path4.join(vaultPath2, notePath);
+  let content;
+  try {
+    content = await fs5.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 = path4.join(vaultPath2, notePath);
+  let content;
+  try {
+    content = await fs5.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 = path4.join(vaultPath2, note.path);
+    let content;
+    try {
+      content = await fs5.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 fs6 from "fs";
+import * as path5 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 fs6.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, limit } = options;
+  const allTasks = [];
+  for (const note of index.notes.values()) {
+    if (folder && !note.path.startsWith(folder)) continue;
+    const absolutePath = path5.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));
+  }
+  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) {
+  const note = index.notes.get(notePath);
+  if (!note) return null;
+  const absolutePath = path5.join(vaultPath2, notePath);
+  return extractTasksFromNote(notePath, absolutePath);
+}
+async function getTasksWithDueDates(index, vaultPath2, options = {}) {
+  const { status = "open", folder } = options;
+  const result = await getAllTasks(index, vaultPath2, { status, folder });
+  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;
+}
+
+// src/tools/primitives.ts
+function registerPrimitiveTools(server2, getIndex, getVaultPath) {
+  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")
+      }
+    },
+    async ({ date }) => {
+      const index = getIndex();
+      const result = getNotesModifiedOn(index, date);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          date,
+          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")
+      }
+    },
+    async ({ start_date, end_date }) => {
+      const index = getIndex();
+      const result = getNotesInRange(index, start_date, end_date);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          start_date,
+          end_date,
+          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 }) => {
+      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")
+      }
+    },
+    async ({ path: path6, hours }) => {
+      const index = getIndex();
+      const result = getContemporaneousNotes(index, path6, hours);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          reference_note: path6,
+          window_hours: hours,
+          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: path6 }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getNoteStructure(index, path6, vaultPath2);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path6 }, 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: path6 }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getHeadings(index, path6, vaultPath2);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path6 }, null, 2) }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          path: path6,
+          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: path6, heading, include_subheadings }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getSectionContent(index, path6, heading, vaultPath2, include_subheadings);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            error: "Section not found",
+            path: path6,
+            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")
+      }
+    },
+    async ({ pattern, folder }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await findSections(index, pattern, vaultPath2, folder);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          pattern,
+          folder,
+          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(100).describe("Maximum tasks to return")
+      }
+    },
+    async ({ status, folder, tag, limit }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getAllTasks(index, vaultPath2, { status, folder, tag, limit });
+      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: path6 }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getTasksFromNote(index, path6, vaultPath2);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path6 }, null, 2) }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          path: path6,
+          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")
+      }
+    },
+    async ({ status, folder }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await getTasksWithDueDates(index, vaultPath2, { status, folder });
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          count: result.length,
+          tasks: result
+        }, 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")
+      }
+    },
+    async ({ path: path6 }) => {
+      const index = getIndex();
+      const result = findBidirectionalLinks(index, path6);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          scope: path6 || "all",
+          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")
+      }
+    },
+    async ({ folder, min_backlinks }) => {
+      const index = getIndex();
+      const result = findDeadEnds(index, folder, min_backlinks);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          criteria: { folder, min_backlinks },
+          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")
+      }
+    },
+    async ({ folder, min_outlinks }) => {
+      const index = getIndex();
+      const result = findSources(index, folder, min_outlinks);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          criteria: { folder, min_outlinks },
+          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) }]
+      };
+    }
+  );
+}
+
 // src/index.ts
 var VAULT_PATH = process.env.OBSIDIAN_VAULT_PATH;
 if (!VAULT_PATH) {
@@ -1153,7 +2762,7 @@ var vaultPath = VAULT_PATH;
 var vaultIndex;
 var server = new McpServer({
   name: "smoking-mirror",
-  version: "1.0.0"
+  version: "1.2.0"
 });
 registerGraphTools(
   server,
@@ -1175,6 +2784,19 @@ registerQueryTools(
   () => vaultIndex,
   () => vaultPath
 );
+registerSystemTools(
+  server,
+  () => vaultIndex,
+  (newIndex) => {
+    vaultIndex = newIndex;
+  },
+  () => vaultPath
+);
+registerPrimitiveTools(
+  server,
+  () => vaultIndex,
+  () => vaultPath
+);
 async function main() {
   console.error("Building vault index...");
   const startTime = Date.now();