smoking-mirror 1.0.0 → 1.1.0

package/README.md

@@ -188,6 +188,54 @@ Output: [{ path: "work/Current.md", title: "Current", frontmatter: {...}, tags:
 - `order` - "asc" or "desc"
 - `limit` - Maximum results to return
 
+### System (v1.1)
+
+#### `refresh_index`
+Rebuild the vault index without restarting the server.
+
+```
+Output: { success: true, notes_count: 1444, entities_count: 3421, duration_ms: 1823 }
+```
+
+#### `get_all_entities`
+Get all linkable entities (note titles and aliases).
+
+```
+Input: { include_aliases: true, limit: 100 }
+Output: { entity_count: 100, entities: [{ name: "John Smith", path: "people/John Smith.md", is_alias: false }] }
+```
+
+#### `get_recent_notes`
+Get notes modified within the last N days.
+
+```
+Input: { days: 7, limit: 50 }
+Output: { count: 23, days: 7, notes: [{ path: "daily/2024-01-15.md", title: "2024-01-15", modified: "...", tags: [...] }] }
+```
+
+#### `get_unlinked_mentions`
+Find mentions of an entity that aren't linked (linking opportunities).
+
+```
+Input: { entity: "John Smith", limit: 50 }
+Output: { entity: "John Smith", mention_count: 12, mentions: [{ path: "meetings/standup.md", line: 5, context: "Talked to John Smith about..." }] }
+```
+
+#### `get_note_metadata`
+Get metadata about a note without reading full content.
+
+```
+Input: { path: "projects/API.md", include_word_count: true }
+Output: { path: "...", title: "API", frontmatter: {...}, tags: [...], outlink_count: 15, backlink_count: 8, word_count: 2340 }
+```
+
+#### `get_folder_structure`
+Get the folder structure of the vault with note counts.
+
+```
+Output: { folder_count: 12, folders: [{ path: "daily", note_count: 365, subfolder_count: 0 }] }
+```
+
 ## Architecture
 
 - **File-first**: Parses markdown directly, no database required

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(path4) {
+  return path4.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, path4] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path3;
+        return path4;
       }
     }
-    for (const [name, path3] of entities) {
+    for (const [name, path4] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path3;
+        return path4;
       }
     }
     return void 0;
@@ -1143,6 +1143,447 @@ 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/index.ts
 var VAULT_PATH = process.env.OBSIDIAN_VAULT_PATH;
 if (!VAULT_PATH) {
@@ -1153,7 +1594,7 @@ var vaultPath = VAULT_PATH;
 var vaultIndex;
 var server = new McpServer({
   name: "smoking-mirror",
-  version: "1.0.0"
+  version: "1.1.0"
 });
 registerGraphTools(
   server,
@@ -1175,6 +1616,14 @@ registerQueryTools(
   () => vaultIndex,
   () => vaultPath
 );
+registerSystemTools(
+  server,
+  () => vaultIndex,
+  (newIndex) => {
+    vaultIndex = newIndex;
+  },
+  () => vaultPath
+);
 async function main() {
   console.error("Building vault index...");
   const startTime = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoking-mirror",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Obsidian vault intelligence MCP server - graph queries, wikilink suggestions, vault health",
   "type": "module",
   "main": "dist/index.js",