@velvetmonkey/flywheel-crank 0.2.1 → 0.3.1

package/dist/index.js

@@ -16,6 +16,22 @@ import matter from "gray-matter";
 var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
 
 // src/core/writer.ts
+var EMPTY_PLACEHOLDER_PATTERNS = [
+  /^\d+\.\s*$/,
+  // "1. " or "2. " (numbered list placeholder)
+  /^-\s*$/,
+  // "- " (bullet placeholder)
+  /^-\s*\[\s*\]\s*$/,
+  // "- [ ] " (empty task placeholder)
+  /^-\s*\[x\]\s*$/i,
+  // "- [x] " (completed task placeholder)
+  /^\*\s*$/
+  // "* " (asterisk bullet placeholder)
+];
+function isEmptyPlaceholder(line) {
+  const trimmed = line.trim();
+  return EMPTY_PLACEHOLDER_PATTERNS.some((p) => p.test(trimmed));
+}
 function extractHeadings(content) {
   const lines = content.split("\n");
   const headings = [];
@@ -93,13 +109,29 @@ function insertInSection(content, section, newContent, position) {
   if (position === "prepend") {
     lines.splice(section.contentStartLine, 0, formattedContent);
   } else {
-    let insertLine = section.endLine + 1;
-    if (section.contentStartLine <= section.endLine) {
-      insertLine = section.endLine + 1;
+    let lastContentLineIdx = -1;
+    for (let i = section.endLine; i >= section.contentStartLine; i--) {
+      if (lines[i].trim() !== "") {
+        lastContentLineIdx = i;
+        break;
+      }
+    }
+    if (lastContentLineIdx >= section.contentStartLine && isEmptyPlaceholder(lines[lastContentLineIdx])) {
+      lines[lastContentLineIdx] = formattedContent;
     } else {
-      insertLine = section.contentStartLine;
+      let insertLine;
+      if (lastContentLineIdx >= section.contentStartLine) {
+        for (let i = section.endLine; i > lastContentLineIdx; i--) {
+          if (lines[i].trim() === "") {
+            lines.splice(i, 1);
+          }
+        }
+        insertLine = lastContentLineIdx + 1;
+      } else {
+        insertLine = section.contentStartLine;
+      }
+      lines.splice(insertLine, 0, formattedContent);
     }
-    lines.splice(insertLine, 0, formattedContent);
   }
   return lines.join("\n");
 }
@@ -305,9 +337,104 @@ async function undoLastCommit(vaultPath2) {
   }
 }
 
+// src/core/wikilinks.ts
+import {
+  scanVaultEntities,
+  getAllEntities,
+  applyWikilinks,
+  loadEntityCache,
+  saveEntityCache
+} from "@velvetmonkey/vault-core";
+import path3 from "path";
+var entityIndex = null;
+var indexReady = false;
+var indexError = null;
+var DEFAULT_EXCLUDE_FOLDERS = [
+  "daily-notes",
+  "daily",
+  "weekly",
+  "monthly",
+  "quarterly",
+  "periodic",
+  "journal",
+  "inbox",
+  "templates"
+];
+async function initializeEntityIndex(vaultPath2) {
+  const cacheFile = path3.join(vaultPath2, ".claude", "wikilink-entities.json");
+  try {
+    const cached = await loadEntityCache(cacheFile);
+    if (cached) {
+      entityIndex = cached;
+      indexReady = true;
+      console.error(`[Crank] Loaded ${cached._metadata.total_entities} entities from cache`);
+      const cacheAge = Date.now() - new Date(cached._metadata.generated_at).getTime();
+      if (cacheAge > 60 * 60 * 1e3) {
+        rebuildIndexInBackground(vaultPath2, cacheFile);
+      }
+      return;
+    }
+    await rebuildIndex(vaultPath2, cacheFile);
+  } catch (error) {
+    indexError = error instanceof Error ? error : new Error(String(error));
+    console.error(`[Crank] Failed to initialize entity index: ${indexError.message}`);
+  }
+}
+async function rebuildIndex(vaultPath2, cacheFile) {
+  console.error(`[Crank] Scanning vault for entities...`);
+  const startTime = Date.now();
+  entityIndex = await scanVaultEntities(vaultPath2, {
+    excludeFolders: DEFAULT_EXCLUDE_FOLDERS
+  });
+  indexReady = true;
+  const duration = Date.now() - startTime;
+  console.error(`[Crank] Entity index built: ${entityIndex._metadata.total_entities} entities in ${duration}ms`);
+  try {
+    await saveEntityCache(cacheFile, entityIndex);
+    console.error(`[Crank] Entity cache saved`);
+  } catch (e) {
+    console.error(`[Crank] Failed to save entity cache: ${e}`);
+  }
+}
+function rebuildIndexInBackground(vaultPath2, cacheFile) {
+  rebuildIndex(vaultPath2, cacheFile).catch((error) => {
+    console.error(`[Crank] Background index rebuild failed: ${error}`);
+  });
+}
+function isEntityIndexReady() {
+  return indexReady && entityIndex !== null;
+}
+function processWikilinks(content) {
+  if (!isEntityIndexReady() || !entityIndex) {
+    return {
+      content,
+      linksAdded: 0,
+      linkedEntities: []
+    };
+  }
+  const entities = getAllEntities(entityIndex);
+  return applyWikilinks(content, entities, {
+    firstOccurrenceOnly: true,
+    caseInsensitive: true
+  });
+}
+function maybeApplyWikilinks(content, skipWikilinks) {
+  if (skipWikilinks) {
+    return { content };
+  }
+  const result = processWikilinks(content);
+  if (result.linksAdded > 0) {
+    return {
+      content: result.content,
+      wikilinkInfo: `Applied ${result.linksAdded} wikilink(s): ${result.linkedEntities.join(", ")}`
+    };
+  }
+  return { content: result.content };
+}
+
 // src/tools/mutations.ts
 import fs2 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 function registerMutationTools(server2, vaultPath2) {
   server2.tool(
     "vault_add_to_section",
@@ -318,11 +445,12 @@ function registerMutationTools(server2, vaultPath2) {
       content: z.string().describe("Content to add to the section"),
       position: z.enum(["append", "prepend"]).default("append").describe("Where to insert content"),
       format: z.enum(["plain", "bullet", "task", "numbered", "timestamp-bullet"]).default("plain").describe("How to format the content"),
-      commit: z.boolean().default(false).describe("If true, commit this change to git (creates undo point)")
+      commit: z.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
+      skipWikilinks: z.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)")
     },
-    async ({ path: notePath, section, content, position, format, commit }) => {
+    async ({ path: notePath, section, content, position, format, commit, skipWikilinks }) => {
       try {
-        const fullPath = path3.join(vaultPath2, notePath);
+        const fullPath = path4.join(vaultPath2, notePath);
         try {
           await fs2.access(fullPath);
         } catch {
@@ -343,7 +471,8 @@ function registerMutationTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const formattedContent = formatContent(content, format);
+        const { content: wikilinkedContent, wikilinkInfo } = maybeApplyWikilinks(content, skipWikilinks);
+        const formattedContent = formatContent(wikilinkedContent, format);
         const updatedContent = insertInSection(
           fileContent,
           sectionBoundary,
@@ -361,7 +490,8 @@ function registerMutationTools(server2, vaultPath2) {
             gitError = gitResult.error;
           }
         }
-        const preview = formattedContent;
+        const preview = formattedContent + (wikilinkInfo ? `
+(${wikilinkInfo})` : "");
         const result = {
           success: true,
           message: `Added content to section "${sectionBoundary.name}" in ${notePath}`,
@@ -394,7 +524,7 @@ function registerMutationTools(server2, vaultPath2) {
     },
     async ({ path: notePath, section, pattern, mode, useRegex, commit }) => {
       try {
-        const fullPath = path3.join(vaultPath2, notePath);
+        const fullPath = path4.join(vaultPath2, notePath);
         try {
           await fs2.access(fullPath);
         } catch {
@@ -470,11 +600,12 @@ function registerMutationTools(server2, vaultPath2) {
       replacement: z.string().describe("Text to replace with"),
       mode: z.enum(["first", "last", "all"]).default("first").describe("Which matches to replace"),
       useRegex: z.boolean().default(false).describe("Treat search as regex"),
-      commit: z.boolean().default(false).describe("If true, commit this change to git (creates undo point)")
+      commit: z.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
+      skipWikilinks: z.boolean().default(false).describe("If true, skip auto-wikilink application on replacement text")
     },
-    async ({ path: notePath, section, search, replacement, mode, useRegex, commit }) => {
+    async ({ path: notePath, section, search, replacement, mode, useRegex, commit, skipWikilinks }) => {
       try {
-        const fullPath = path3.join(vaultPath2, notePath);
+        const fullPath = path4.join(vaultPath2, notePath);
         try {
           await fs2.access(fullPath);
         } catch {
@@ -495,11 +626,12 @@ function registerMutationTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
+        const { content: wikilinkedReplacement, wikilinkInfo } = maybeApplyWikilinks(replacement, skipWikilinks);
         const replaceResult = replaceInSection(
           fileContent,
           sectionBoundary,
           search,
-          replacement,
+          wikilinkedReplacement,
           mode,
           useRegex
         );
@@ -551,7 +683,7 @@ function registerMutationTools(server2, vaultPath2) {
 // src/tools/tasks.ts
 import { z as z2 } from "zod";
 import fs3 from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 var TASK_REGEX = /^(\s*)-\s*\[([ xX])\]\s*(.*)$/;
 function findTasks(content, section) {
   const lines = content.split("\n");
@@ -607,7 +739,7 @@ function registerTaskTools(server2, vaultPath2) {
     },
     async ({ path: notePath, task, section, commit }) => {
       try {
-        const fullPath = path4.join(vaultPath2, notePath);
+        const fullPath = path5.join(vaultPath2, notePath);
         try {
           await fs3.access(fullPath);
         } catch {
@@ -695,11 +827,12 @@ function registerTaskTools(server2, vaultPath2) {
       task: z2.string().describe("Task text (without checkbox)"),
       position: z2.enum(["append", "prepend"]).default("append").describe("Where to add the task"),
       completed: z2.boolean().default(false).describe("Whether the task should start as completed"),
-      commit: z2.boolean().default(false).describe("If true, commit this change to git (creates undo point)")
+      commit: z2.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
+      skipWikilinks: z2.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)")
     },
-    async ({ path: notePath, section, task, position, completed, commit }) => {
+    async ({ path: notePath, section, task, position, completed, commit, skipWikilinks }) => {
       try {
-        const fullPath = path4.join(vaultPath2, notePath);
+        const fullPath = path5.join(vaultPath2, notePath);
         try {
           await fs3.access(fullPath);
         } catch {
@@ -720,8 +853,9 @@ function registerTaskTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
+        const { content: wikilinkedTask, wikilinkInfo } = maybeApplyWikilinks(task.trim(), skipWikilinks);
         const checkbox = completed ? "[x]" : "[ ]";
-        const taskLine = `- ${checkbox} ${task.trim()}`;
+        const taskLine = `- ${checkbox} ${wikilinkedTask}`;
         const updatedContent = insertInSection(
           fileContent,
           sectionBoundary,
@@ -743,7 +877,8 @@ function registerTaskTools(server2, vaultPath2) {
           success: true,
           message: `Added task to section "${sectionBoundary.name}" in ${notePath}`,
           path: notePath,
-          preview: taskLine,
+          preview: taskLine + (wikilinkInfo ? `
+(${wikilinkInfo})` : ""),
           gitCommit,
           gitError
         };
@@ -764,7 +899,7 @@ function registerTaskTools(server2, vaultPath2) {
 // src/tools/frontmatter.ts
 import { z as z3 } from "zod";
 import fs4 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 function registerFrontmatterTools(server2, vaultPath2) {
   server2.tool(
     "vault_update_frontmatter",
@@ -776,7 +911,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
     },
     async ({ path: notePath, frontmatter: updates, commit }) => {
       try {
-        const fullPath = path5.join(vaultPath2, notePath);
+        const fullPath = path6.join(vaultPath2, notePath);
         try {
           await fs4.access(fullPath);
         } catch {
@@ -832,7 +967,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
     },
     async ({ path: notePath, key, value, commit }) => {
       try {
-        const fullPath = path5.join(vaultPath2, notePath);
+        const fullPath = path6.join(vaultPath2, notePath);
         try {
           await fs4.access(fullPath);
         } catch {
@@ -889,7 +1024,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
 // src/tools/notes.ts
 import { z as z4 } from "zod";
 import fs5 from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 function registerNoteTools(server2, vaultPath2) {
   server2.tool(
     "vault_create_note",
@@ -911,7 +1046,7 @@ function registerNoteTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const fullPath = path6.join(vaultPath2, notePath);
+        const fullPath = path7.join(vaultPath2, notePath);
         try {
           await fs5.access(fullPath);
           if (!overwrite) {
@@ -924,7 +1059,7 @@ function registerNoteTools(server2, vaultPath2) {
           }
         } catch {
         }
-        const dir = path6.dirname(fullPath);
+        const dir = path7.dirname(fullPath);
         await fs5.mkdir(dir, { recursive: true });
         await writeVaultFile(vaultPath2, notePath, content, frontmatter);
         let gitCommit;
@@ -983,7 +1118,7 @@ Content length: ${content.length} chars`,
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const fullPath = path6.join(vaultPath2, notePath);
+        const fullPath = path7.join(vaultPath2, notePath);
         try {
           await fs5.access(fullPath);
         } catch {
@@ -1029,7 +1164,7 @@ Content length: ${content.length} chars`,
 // src/tools/system.ts
 import { z as z5 } from "zod";
 import fs6 from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 function registerSystemTools(server2, vaultPath2) {
   server2.tool(
     "vault_list_sections",
@@ -1049,7 +1184,7 @@ function registerSystemTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const fullPath = path7.join(vaultPath2, notePath);
+        const fullPath = path8.join(vaultPath2, notePath);
         try {
           await fs6.access(fullPath);
         } catch {
@@ -1157,18 +1292,18 @@ Message: ${undoResult.undoneCommit.message}` : void 0
 
 // src/core/vaultRoot.ts
 import * as fs7 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 var VAULT_MARKERS = [".obsidian", ".claude"];
 function findVaultRoot(startPath) {
-  let current = path8.resolve(startPath || process.cwd());
+  let current = path9.resolve(startPath || process.cwd());
   while (true) {
     for (const marker of VAULT_MARKERS) {
-      const markerPath = path8.join(current, marker);
+      const markerPath = path9.join(current, marker);
       if (fs7.existsSync(markerPath) && fs7.statSync(markerPath).isDirectory()) {
         return current;
       }
     }
-    const parent = path8.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) {
       return startPath || process.cwd();
     }
@@ -1179,11 +1314,14 @@ function findVaultRoot(startPath) {
 // src/index.ts
 var server = new McpServer({
   name: "flywheel-crank",
-  version: "0.1.0"
+  version: "0.3.0"
 });
 var vaultPath = process.env.PROJECT_PATH || findVaultRoot();
 console.error(`[Crank] Starting Flywheel Crank MCP server`);
 console.error(`[Crank] Vault path: ${vaultPath}`);
+initializeEntityIndex(vaultPath).catch((err) => {
+  console.error(`[Crank] Entity index initialization failed: ${err}`);
+});
 registerMutationTools(server, vaultPath);
 registerTaskTools(server, vaultPath);
 registerFrontmatterTools(server, vaultPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-crank",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Deterministic vault mutations for Obsidian via MCP",
   "type": "module",
   "main": "dist/index.js",
@@ -36,6 +36,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
+    "@velvetmonkey/vault-core": "^0.1.0",
     "gray-matter": "^4.0.3",
     "zod": "^3.22.4",
     "simple-git": "^3.22.0"