@velvetmonkey/flywheel-crank 0.5.1 → 0.6.1

package/dist/index.js

@@ -492,23 +492,525 @@ import {
   loadEntityCache,
   saveEntityCache
 } from "@velvetmonkey/vault-core";
+import path4 from "path";
+
+// src/core/stemmer.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "as",
+  "is",
+  "was",
+  "are",
+  "were",
+  "been",
+  "be",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "can",
+  "need",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "you",
+  "he",
+  "she",
+  "it",
+  "we",
+  "they",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "also",
+  "about",
+  "after",
+  "before",
+  "being",
+  "between",
+  "into",
+  "through",
+  "during",
+  "above",
+  "below",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "any",
+  "now",
+  "new",
+  "even",
+  "much",
+  "back",
+  "going"
+]);
+function isConsonant(word, i) {
+  const c = word[i];
+  if (c === "a" || c === "e" || c === "i" || c === "o" || c === "u") {
+    return false;
+  }
+  if (c === "y") {
+    return i === 0 || !isConsonant(word, i - 1);
+  }
+  return true;
+}
+function measure(word, end) {
+  let n = 0;
+  let i = 0;
+  while (i <= end) {
+    if (!isConsonant(word, i))
+      break;
+    i++;
+  }
+  if (i > end)
+    return n;
+  i++;
+  while (true) {
+    while (i <= end) {
+      if (isConsonant(word, i))
+        break;
+      i++;
+    }
+    if (i > end)
+      return n;
+    n++;
+    i++;
+    while (i <= end) {
+      if (!isConsonant(word, i))
+        break;
+      i++;
+    }
+    if (i > end)
+      return n;
+    i++;
+  }
+}
+function hasVowel(word, end) {
+  for (let i = 0; i <= end; i++) {
+    if (!isConsonant(word, i))
+      return true;
+  }
+  return false;
+}
+function endsWithDoubleConsonant(word, end) {
+  if (end < 1)
+    return false;
+  if (word[end] !== word[end - 1])
+    return false;
+  return isConsonant(word, end);
+}
+function cvcPattern(word, i) {
+  if (i < 2)
+    return false;
+  if (!isConsonant(word, i) || isConsonant(word, i - 1) || !isConsonant(word, i - 2)) {
+    return false;
+  }
+  const c = word[i];
+  return c !== "w" && c !== "x" && c !== "y";
+}
+function replaceSuffix(word, suffix, replacement, minMeasure) {
+  if (!word.endsWith(suffix))
+    return word;
+  const stem2 = word.slice(0, word.length - suffix.length);
+  if (measure(stem2, stem2.length - 1) > minMeasure) {
+    return stem2 + replacement;
+  }
+  return word;
+}
+function step1a(word) {
+  if (word.endsWith("sses")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("ies")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("ss")) {
+    return word;
+  }
+  if (word.endsWith("s")) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function step1b(word) {
+  if (word.endsWith("eed")) {
+    const stem3 = word.slice(0, -3);
+    if (measure(stem3, stem3.length - 1) > 0) {
+      return stem3 + "ee";
+    }
+    return word;
+  }
+  let stem2 = "";
+  let didRemove = false;
+  if (word.endsWith("ed")) {
+    stem2 = word.slice(0, -2);
+    if (hasVowel(stem2, stem2.length - 1)) {
+      word = stem2;
+      didRemove = true;
+    }
+  } else if (word.endsWith("ing")) {
+    stem2 = word.slice(0, -3);
+    if (hasVowel(stem2, stem2.length - 1)) {
+      word = stem2;
+      didRemove = true;
+    }
+  }
+  if (didRemove) {
+    if (word.endsWith("at") || word.endsWith("bl") || word.endsWith("iz")) {
+      return word + "e";
+    }
+    if (endsWithDoubleConsonant(word, word.length - 1)) {
+      const c = word[word.length - 1];
+      if (c !== "l" && c !== "s" && c !== "z") {
+        return word.slice(0, -1);
+      }
+    }
+    if (measure(word, word.length - 1) === 1 && cvcPattern(word, word.length - 1)) {
+      return word + "e";
+    }
+  }
+  return word;
+}
+function step1c(word) {
+  if (word.endsWith("y")) {
+    const stem2 = word.slice(0, -1);
+    if (hasVowel(stem2, stem2.length - 1)) {
+      return stem2 + "i";
+    }
+  }
+  return word;
+}
+function step2(word) {
+  const suffixes = [
+    ["ational", "ate"],
+    ["tional", "tion"],
+    ["enci", "ence"],
+    ["anci", "ance"],
+    ["izer", "ize"],
+    ["abli", "able"],
+    ["alli", "al"],
+    ["entli", "ent"],
+    ["eli", "e"],
+    ["ousli", "ous"],
+    ["ization", "ize"],
+    ["ation", "ate"],
+    ["ator", "ate"],
+    ["alism", "al"],
+    ["iveness", "ive"],
+    ["fulness", "ful"],
+    ["ousness", "ous"],
+    ["aliti", "al"],
+    ["iviti", "ive"],
+    ["biliti", "ble"]
+  ];
+  for (const [suffix, replacement] of suffixes) {
+    if (word.endsWith(suffix)) {
+      return replaceSuffix(word, suffix, replacement, 0);
+    }
+  }
+  return word;
+}
+function step3(word) {
+  const suffixes = [
+    ["icate", "ic"],
+    ["ative", ""],
+    ["alize", "al"],
+    ["iciti", "ic"],
+    ["ical", "ic"],
+    ["ful", ""],
+    ["ness", ""]
+  ];
+  for (const [suffix, replacement] of suffixes) {
+    if (word.endsWith(suffix)) {
+      return replaceSuffix(word, suffix, replacement, 0);
+    }
+  }
+  return word;
+}
+function step4(word) {
+  const suffixes = [
+    "al",
+    "ance",
+    "ence",
+    "er",
+    "ic",
+    "able",
+    "ible",
+    "ant",
+    "ement",
+    "ment",
+    "ent",
+    "ion",
+    "ou",
+    "ism",
+    "ate",
+    "iti",
+    "ous",
+    "ive",
+    "ize"
+  ];
+  for (const suffix of suffixes) {
+    if (word.endsWith(suffix)) {
+      const stem2 = word.slice(0, word.length - suffix.length);
+      if (measure(stem2, stem2.length - 1) > 1) {
+        if (suffix === "ion") {
+          const lastChar = stem2[stem2.length - 1];
+          if (lastChar === "s" || lastChar === "t") {
+            return stem2;
+          }
+        } else {
+          return stem2;
+        }
+      }
+    }
+  }
+  return word;
+}
+function step5a(word) {
+  if (word.endsWith("e")) {
+    const stem2 = word.slice(0, -1);
+    const m = measure(stem2, stem2.length - 1);
+    if (m > 1) {
+      return stem2;
+    }
+    if (m === 1 && !cvcPattern(stem2, stem2.length - 1)) {
+      return stem2;
+    }
+  }
+  return word;
+}
+function step5b(word) {
+  if (word.endsWith("ll")) {
+    const stem2 = word.slice(0, -1);
+    if (measure(stem2, stem2.length - 1) > 1) {
+      return stem2;
+    }
+  }
+  return word;
+}
+function stem(word) {
+  word = word.toLowerCase();
+  if (word.length < 3) {
+    return word;
+  }
+  word = step1a(word);
+  word = step1b(word);
+  word = step1c(word);
+  word = step2(word);
+  word = step3(word);
+  word = step4(word);
+  word = step5a(word);
+  word = step5b(word);
+  return word;
+}
+function tokenize(text) {
+  const cleanText = text.replace(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g, "$1").replace(/[*_`#\[\]()]/g, " ").toLowerCase();
+  const words = cleanText.match(/\b[a-z]{4,}\b/g) || [];
+  return words.filter((word) => !STOPWORDS.has(word));
+}
+
+// src/core/cooccurrence.ts
+import { readdir, readFile } from "fs/promises";
 import path3 from "path";
+var DEFAULT_MIN_COOCCURRENCE = 2;
+var EXCLUDED_FOLDERS = /* @__PURE__ */ new Set([
+  "templates",
+  ".obsidian",
+  ".claude",
+  ".git"
+]);
+function noteContainsEntity(content, entityName) {
+  const entityTokens = tokenize(entityName);
+  if (entityTokens.length === 0)
+    return false;
+  const contentTokens = new Set(tokenize(content));
+  let matchCount = 0;
+  for (const token of entityTokens) {
+    if (contentTokens.has(token)) {
+      matchCount++;
+    }
+  }
+  if (entityTokens.length === 1) {
+    return matchCount === 1;
+  }
+  return matchCount / entityTokens.length >= 0.5;
+}
+function incrementCooccurrence(associations, entityA, entityB) {
+  if (!associations[entityA]) {
+    associations[entityA] = /* @__PURE__ */ new Map();
+  }
+  const current = associations[entityA].get(entityB) || 0;
+  associations[entityA].set(entityB, current + 1);
+}
+async function* walkMarkdownFiles(dir, baseDir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      const relativePath = path3.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path3.sep)[0];
+      if (EXCLUDED_FOLDERS.has(topFolder)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        yield* walkMarkdownFiles(fullPath, baseDir);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        yield { path: fullPath, relativePath };
+      }
+    }
+  } catch {
+  }
+}
+async function mineCooccurrences(vaultPath2, entities, options = {}) {
+  const { minCount = DEFAULT_MIN_COOCCURRENCE } = options;
+  const associations = {};
+  let notesScanned = 0;
+  const validEntities = entities.filter((e) => e.length <= 30);
+  for await (const file of walkMarkdownFiles(vaultPath2, vaultPath2)) {
+    try {
+      const content = await readFile(file.path, "utf-8");
+      notesScanned++;
+      const mentionedEntities = [];
+      for (const entity of validEntities) {
+        if (noteContainsEntity(content, entity)) {
+          mentionedEntities.push(entity);
+        }
+      }
+      for (const entityA of mentionedEntities) {
+        for (const entityB of mentionedEntities) {
+          if (entityA !== entityB) {
+            incrementCooccurrence(associations, entityA, entityB);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  let totalAssociations = 0;
+  for (const entityAssocs of Object.values(associations)) {
+    for (const count of entityAssocs.values()) {
+      if (count >= minCount) {
+        totalAssociations++;
+      }
+    }
+  }
+  return {
+    associations,
+    minCount,
+    _metadata: {
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      total_associations: totalAssociations,
+      notes_scanned: notesScanned
+    }
+  };
+}
+function getCooccurrenceBoost(entityName, matchedEntities, cooccurrenceIndex2) {
+  if (!cooccurrenceIndex2)
+    return 0;
+  let boost = 0;
+  const { associations, minCount } = cooccurrenceIndex2;
+  for (const matched of matchedEntities) {
+    const entityAssocs = associations[matched];
+    if (entityAssocs) {
+      const count = entityAssocs.get(entityName) || 0;
+      if (count >= minCount) {
+        boost += 3;
+      }
+    }
+  }
+  return boost;
+}
+
+// src/core/wikilinks.ts
 var entityIndex = null;
 var indexReady = false;
 var indexError = null;
+var cooccurrenceIndex = null;
 var DEFAULT_EXCLUDE_FOLDERS = [
+  // Periodic notes
   "daily-notes",
   "daily",
   "weekly",
+  "weekly-notes",
   "monthly",
+  "monthly-notes",
   "quarterly",
+  "yearly-notes",
   "periodic",
   "journal",
+  // Working folders
   "inbox",
-  "templates"
+  "templates",
+  "attachments",
+  "tmp",
+  "new",
+  // Clippings & external content (article titles are not concepts)
+  "clippings",
+  "readwise",
+  "articles",
+  "bookmarks",
+  "web-clips"
 ];
 async function initializeEntityIndex(vaultPath2) {
-  const cacheFile = path3.join(vaultPath2, ".claude", "wikilink-entities.json");
+  const cacheFile = path4.join(vaultPath2, ".claude", "wikilink-entities.json");
   try {
     const cached = await loadEntityCache(cacheFile);
     if (cached) {
@@ -534,8 +1036,17 @@ async function rebuildIndex(vaultPath2, cacheFile) {
     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`);
+  const entityDuration = Date.now() - startTime;
+  console.error(`[Crank] Entity index built: ${entityIndex._metadata.total_entities} entities in ${entityDuration}ms`);
+  try {
+    const cooccurrenceStart = Date.now();
+    const entities = getAllEntities(entityIndex);
+    cooccurrenceIndex = await mineCooccurrences(vaultPath2, entities);
+    const cooccurrenceDuration = Date.now() - cooccurrenceStart;
+    console.error(`[Crank] Co-occurrence index built: ${cooccurrenceIndex._metadata.total_associations} associations in ${cooccurrenceDuration}ms`);
+  } catch (e) {
+    console.error(`[Crank] Failed to build co-occurrence index: ${e}`);
+  }
   try {
     await saveEntityCache(cacheFile, entityIndex);
     console.error(`[Crank] Entity cache saved`);
@@ -579,86 +1090,6 @@ function maybeApplyWikilinks(content, skipWikilinks) {
   return { content: result.content };
 }
 var SUGGESTION_PATTERN = /→\s*\[\[.+$/;
-var STOPWORDS = /* @__PURE__ */ new Set([
-  "the",
-  "a",
-  "an",
-  "and",
-  "or",
-  "but",
-  "in",
-  "on",
-  "at",
-  "to",
-  "for",
-  "of",
-  "with",
-  "by",
-  "from",
-  "as",
-  "is",
-  "was",
-  "are",
-  "were",
-  "been",
-  "be",
-  "have",
-  "has",
-  "had",
-  "do",
-  "does",
-  "did",
-  "will",
-  "would",
-  "could",
-  "should",
-  "may",
-  "might",
-  "must",
-  "shall",
-  "can",
-  "need",
-  "this",
-  "that",
-  "these",
-  "those",
-  "i",
-  "you",
-  "he",
-  "she",
-  "it",
-  "we",
-  "they",
-  "what",
-  "which",
-  "who",
-  "whom",
-  "when",
-  "where",
-  "why",
-  "how",
-  "all",
-  "each",
-  "every",
-  "both",
-  "few",
-  "more",
-  "most",
-  "other",
-  "some",
-  "such",
-  "no",
-  "not",
-  "only",
-  "own",
-  "same",
-  "so",
-  "than",
-  "too",
-  "very",
-  "just",
-  "also"
-]);
 function extractLinkedEntities(content) {
   const linked = /* @__PURE__ */ new Set();
   const wikilinkRegex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
@@ -668,23 +1099,61 @@ function extractLinkedEntities(content) {
   }
   return linked;
 }
-function tokenizeContent(content) {
-  const cleanContent = content.replace(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g, "$1").replace(/[*_`#\[\]()]/g, " ").toLowerCase();
-  const words = cleanContent.match(/\b[a-z]{4,}\b/g) || [];
-  return words.filter((word) => !STOPWORDS.has(word));
+function tokenizeForMatching(content) {
+  const tokens = tokenize(content);
+  const tokenSet = new Set(tokens);
+  const stems = new Set(tokens.map((t) => stem(t)));
+  return { tokens: tokenSet, stems };
+}
+var MAX_ENTITY_LENGTH = 25;
+var MAX_ENTITY_WORDS = 3;
+var ARTICLE_PATTERNS = [
+  /\bguide\s+to\b/i,
+  /\bhow\s+to\b/i,
+  /\bcomplete\s+/i,
+  /\bultimate\s+/i,
+  /\bchecklist\b/i,
+  /\bcheatsheet\b/i,
+  /\bcheat\s+sheet\b/i,
+  /\bbest\s+practices\b/i,
+  /\bintroduction\s+to\b/i,
+  /\btutorial\b/i,
+  /\bworksheet\b/i
+];
+function isLikelyArticleTitle(name) {
+  if (ARTICLE_PATTERNS.some((pattern) => pattern.test(name))) {
+    return true;
+  }
+  const words = name.split(/\s+/).filter((w) => w.length > 0);
+  if (words.length > MAX_ENTITY_WORDS) {
+    return true;
+  }
+  return false;
 }
-function scoreEntity(entityName, contentTokens) {
-  const entityWords = entityName.toLowerCase().split(/\s+/);
+var MIN_SUGGESTION_SCORE = 5;
+var MIN_MATCH_RATIO = 0.4;
+function scoreEntity(entityName, contentTokens, contentStems) {
+  const entityTokens = tokenize(entityName);
+  if (entityTokens.length === 0)
+    return 0;
+  const entityStems = entityTokens.map((t) => stem(t));
   let score = 0;
-  for (const entityWord of entityWords) {
-    if (entityWord.length < 3)
-      continue;
-    for (const contentToken of contentTokens) {
-      if (contentToken === entityWord) {
-        score += 3;
-      } else if (contentToken.includes(entityWord) || entityWord.includes(contentToken)) {
-        score += 1;
-      }
+  let matchedWords = 0;
+  for (let i = 0; i < entityTokens.length; i++) {
+    const token = entityTokens[i];
+    const entityStem = entityStems[i];
+    if (contentTokens.has(token)) {
+      score += 10;
+      matchedWords++;
+    } else if (contentStems.has(entityStem)) {
+      score += 5;
+      matchedWords++;
+    }
+  }
+  if (entityTokens.length > 1) {
+    const matchRatio = matchedWords / entityTokens.length;
+    if (matchRatio < MIN_MATCH_RATIO) {
+      return 0;
     }
   }
   return score;
@@ -702,24 +1171,56 @@ function suggestRelatedLinks(content, options = {}) {
   if (entities.length === 0) {
     return emptyResult;
   }
-  const contentTokens = tokenizeContent(content);
-  if (contentTokens.length === 0) {
+  const { tokens: contentTokens, stems: contentStems } = tokenizeForMatching(content);
+  if (contentTokens.size === 0) {
     return emptyResult;
   }
   const linkedEntities = excludeLinked ? extractLinkedEntities(content) : /* @__PURE__ */ new Set();
   const scoredEntities = [];
+  const directlyMatchedEntities = /* @__PURE__ */ new Set();
   for (const entity of entities) {
     const entityName = typeof entity === "string" ? entity : entity.name;
     if (!entityName)
       continue;
+    if (entityName.length > MAX_ENTITY_LENGTH) {
+      continue;
+    }
+    if (isLikelyArticleTitle(entityName)) {
+      continue;
+    }
     if (linkedEntities.has(entityName.toLowerCase())) {
       continue;
     }
-    const score = scoreEntity(entityName, contentTokens);
+    const score = scoreEntity(entityName, contentTokens, contentStems);
     if (score > 0) {
+      directlyMatchedEntities.add(entityName);
+    }
+    if (score >= MIN_SUGGESTION_SCORE) {
       scoredEntities.push({ name: entityName, score });
     }
   }
+  if (cooccurrenceIndex && directlyMatchedEntities.size > 0) {
+    for (const entity of entities) {
+      const entityName = typeof entity === "string" ? entity : entity.name;
+      if (!entityName)
+        continue;
+      if (entityName.length > MAX_ENTITY_LENGTH)
+        continue;
+      if (isLikelyArticleTitle(entityName))
+        continue;
+      if (linkedEntities.has(entityName.toLowerCase()))
+        continue;
+      const boost = getCooccurrenceBoost(entityName, directlyMatchedEntities, cooccurrenceIndex);
+      if (boost > 0) {
+        const existing = scoredEntities.find((e) => e.name === entityName);
+        if (existing) {
+          existing.score += boost;
+        } else if (boost >= MIN_SUGGESTION_SCORE) {
+          scoredEntities.push({ name: entityName, score: boost });
+        }
+      }
+    }
+  }
   scoredEntities.sort((a, b) => b.score - a.score);
   const topSuggestions = scoredEntities.slice(0, maxSuggestions).map((e) => e.name);
   if (topSuggestions.length === 0) {
@@ -734,7 +1235,7 @@ function suggestRelatedLinks(content, options = {}) {
 
 // src/tools/mutations.ts
 import fs2 from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 function registerMutationTools(server2, vaultPath2) {
   server2.tool(
     "vault_add_to_section",
@@ -752,7 +1253,7 @@ function registerMutationTools(server2, vaultPath2) {
     },
     async ({ path: notePath, section, content, position, format, commit, skipWikilinks, preserveListNesting, suggestOutgoingLinks }) => {
       try {
-        const fullPath = path4.join(vaultPath2, notePath);
+        const fullPath = path5.join(vaultPath2, notePath);
         try {
           await fs2.access(fullPath);
         } catch {
@@ -836,7 +1337,7 @@ function registerMutationTools(server2, vaultPath2) {
     },
     async ({ path: notePath, section, pattern, mode, useRegex, commit }) => {
       try {
-        const fullPath = path4.join(vaultPath2, notePath);
+        const fullPath = path5.join(vaultPath2, notePath);
         try {
           await fs2.access(fullPath);
         } catch {
@@ -918,7 +1419,7 @@ function registerMutationTools(server2, vaultPath2) {
     },
     async ({ path: notePath, section, search, replacement, mode, useRegex, commit, skipWikilinks, suggestOutgoingLinks }) => {
       try {
-        const fullPath = path4.join(vaultPath2, notePath);
+        const fullPath = path5.join(vaultPath2, notePath);
         try {
           await fs2.access(fullPath);
         } catch {
@@ -1004,7 +1505,7 @@ function registerMutationTools(server2, vaultPath2) {
 // src/tools/tasks.ts
 import { z as z2 } from "zod";
 import fs3 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 var TASK_REGEX = /^(\s*)-\s*\[([ xX])\]\s*(.*)$/;
 function findTasks(content, section) {
   const lines = content.split("\n");
@@ -1060,7 +1561,7 @@ function registerTaskTools(server2, vaultPath2) {
     },
     async ({ path: notePath, task, section, commit }) => {
       try {
-        const fullPath = path5.join(vaultPath2, notePath);
+        const fullPath = path6.join(vaultPath2, notePath);
         try {
           await fs3.access(fullPath);
         } catch {
@@ -1155,7 +1656,7 @@ function registerTaskTools(server2, vaultPath2) {
     },
     async ({ path: notePath, section, task, position, completed, commit, skipWikilinks, suggestOutgoingLinks, preserveListNesting }) => {
       try {
-        const fullPath = path5.join(vaultPath2, notePath);
+        const fullPath = path6.join(vaultPath2, notePath);
         try {
           await fs3.access(fullPath);
         } catch {
@@ -1232,7 +1733,7 @@ function registerTaskTools(server2, vaultPath2) {
 // src/tools/frontmatter.ts
 import { z as z3 } from "zod";
 import fs4 from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 function registerFrontmatterTools(server2, vaultPath2) {
   server2.tool(
     "vault_update_frontmatter",
@@ -1244,7 +1745,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
     },
     async ({ path: notePath, frontmatter: updates, commit }) => {
       try {
-        const fullPath = path6.join(vaultPath2, notePath);
+        const fullPath = path7.join(vaultPath2, notePath);
         try {
           await fs4.access(fullPath);
         } catch {
@@ -1300,7 +1801,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
     },
     async ({ path: notePath, key, value, commit }) => {
       try {
-        const fullPath = path6.join(vaultPath2, notePath);
+        const fullPath = path7.join(vaultPath2, notePath);
         try {
           await fs4.access(fullPath);
         } catch {
@@ -1357,7 +1858,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
 // src/tools/notes.ts
 import { z as z4 } from "zod";
 import fs5 from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 function registerNoteTools(server2, vaultPath2) {
   server2.tool(
     "vault_create_note",
@@ -1379,7 +1880,7 @@ function registerNoteTools(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 fs5.access(fullPath);
           if (!overwrite) {
@@ -1392,7 +1893,7 @@ function registerNoteTools(server2, vaultPath2) {
           }
         } catch {
         }
-        const dir = path7.dirname(fullPath);
+        const dir = path8.dirname(fullPath);
         await fs5.mkdir(dir, { recursive: true });
         await writeVaultFile(vaultPath2, notePath, content, frontmatter);
         let gitCommit;
@@ -1451,7 +1952,7 @@ Content length: ${content.length} chars`,
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const fullPath = path7.join(vaultPath2, notePath);
+        const fullPath = path8.join(vaultPath2, notePath);
         try {
           await fs5.access(fullPath);
         } catch {
@@ -1497,7 +1998,7 @@ Content length: ${content.length} chars`,
 // src/tools/system.ts
 import { z as z5 } from "zod";
 import fs6 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 function registerSystemTools(server2, vaultPath2) {
   server2.tool(
     "vault_list_sections",
@@ -1517,7 +2018,7 @@ function registerSystemTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const fullPath = path8.join(vaultPath2, notePath);
+        const fullPath = path9.join(vaultPath2, notePath);
         try {
           await fs6.access(fullPath);
         } catch {
@@ -1625,18 +2126,18 @@ Message: ${undoResult.undoneCommit.message}` : void 0
 
 // src/core/vaultRoot.ts
 import * as fs7 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 var VAULT_MARKERS = [".obsidian", ".claude"];
 function findVaultRoot(startPath) {
-  let current = path9.resolve(startPath || process.cwd());
+  let current = path10.resolve(startPath || process.cwd());
   while (true) {
     for (const marker of VAULT_MARKERS) {
-      const markerPath = path9.join(current, marker);
+      const markerPath = path10.join(current, marker);
       if (fs7.existsSync(markerPath) && fs7.statSync(markerPath).isDirectory()) {
         return current;
       }
     }
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current) {
       return startPath || process.cwd();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-crank",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Deterministic vault mutations for Obsidian via MCP",
   "type": "module",
   "main": "dist/index.js",