@velvetmonkey/flywheel-crank 0.4.1 → 0.6.0

package/dist/index.js

@@ -16,6 +16,61 @@ import matter from "gray-matter";
 var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
 
 // src/core/writer.ts
+var SENSITIVE_PATH_PATTERNS = [
+  /\.env($|\..*)/i,
+  // .env, .env.local, .env.production, etc.
+  /\.git\/config$/i,
+  // Git config (may contain tokens)
+  /\.git\/credentials$/i,
+  // Git credentials
+  /\.pem$/i,
+  // SSL/TLS certificates
+  /\.key$/i,
+  // Private keys
+  /\.p12$/i,
+  // PKCS#12 certificates
+  /\.pfx$/i,
+  // Windows certificate format
+  /\.jks$/i,
+  // Java keystore
+  /id_rsa/i,
+  // SSH private key
+  /id_ed25519/i,
+  // SSH private key (ed25519)
+  /id_ecdsa/i,
+  // SSH private key (ecdsa)
+  /credentials\.json$/i,
+  // Cloud credentials files
+  /secrets\.json$/i,
+  // Secrets files
+  /secrets\.ya?ml$/i,
+  // Secrets YAML files
+  /\.htpasswd$/i,
+  // Apache password file
+  /shadow$/,
+  // Unix shadow password file
+  /passwd$/
+  // Unix password file
+];
+function isSensitivePath(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return SENSITIVE_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath));
+}
+function detectLineEnding(content) {
+  const crlfCount = (content.match(/\r\n/g) || []).length;
+  const lfCount = (content.match(/(?<!\r)\n/g) || []).length;
+  return crlfCount > lfCount ? "CRLF" : "LF";
+}
+function normalizeLineEndings(content) {
+  return content.replace(/\r\n/g, "\n");
+}
+function convertLineEndings(content, style) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  return style === "CRLF" ? normalized.replace(/\n/g, "\r\n") : normalized;
+}
+function normalizeTrailingNewline(content) {
+  return content.replace(/[\r\n\s]+$/, "") + "\n";
+}
 var EMPTY_PLACEHOLDER_PATTERNS = [
   /^\d+\.\s*$/,
   // "1. " or "2. " (numbered list placeholder)
@@ -169,25 +224,88 @@ function validatePath(vaultPath2, notePath) {
   const resolvedNote = path.resolve(vaultPath2, notePath);
   return resolvedNote.startsWith(resolvedVault);
 }
+async function validatePathSecure(vaultPath2, notePath) {
+  const resolvedVault = path.resolve(vaultPath2);
+  const resolvedNote = path.resolve(vaultPath2, notePath);
+  if (!resolvedNote.startsWith(resolvedVault)) {
+    return {
+      valid: false,
+      reason: "Path traversal not allowed"
+    };
+  }
+  if (isSensitivePath(notePath)) {
+    return {
+      valid: false,
+      reason: "Cannot write to sensitive file (credentials, keys, secrets)"
+    };
+  }
+  try {
+    const fullPath = path.join(vaultPath2, notePath);
+    try {
+      await fs.access(fullPath);
+      const realPath = await fs.realpath(fullPath);
+      const realVaultPath = await fs.realpath(vaultPath2);
+      if (!realPath.startsWith(realVaultPath)) {
+        return {
+          valid: false,
+          reason: "Symlink target is outside vault"
+        };
+      }
+      const relativePath = path.relative(realVaultPath, realPath);
+      if (isSensitivePath(relativePath)) {
+        return {
+          valid: false,
+          reason: "Symlink target is a sensitive file"
+        };
+      }
+    } catch {
+      const parentDir = path.dirname(fullPath);
+      try {
+        await fs.access(parentDir);
+        const realParentPath = await fs.realpath(parentDir);
+        const realVaultPath = await fs.realpath(vaultPath2);
+        if (!realParentPath.startsWith(realVaultPath)) {
+          return {
+            valid: false,
+            reason: "Parent directory symlink target is outside vault"
+          };
+        }
+      } catch {
+      }
+    }
+  } catch (error) {
+    return {
+      valid: false,
+      reason: `Path validation error: ${error.message}`
+    };
+  }
+  return { valid: true };
+}
 async function readVaultFile(vaultPath2, notePath) {
   if (!validatePath(vaultPath2, notePath)) {
     throw new Error("Invalid path: path traversal not allowed");
   }
   const fullPath = path.join(vaultPath2, notePath);
   const rawContent = await fs.readFile(fullPath, "utf-8");
-  const parsed = matter(rawContent);
+  const lineEnding = detectLineEnding(rawContent);
+  const normalizedContent = normalizeLineEndings(rawContent);
+  const parsed = matter(normalizedContent);
   return {
     content: parsed.content,
     frontmatter: parsed.data,
-    rawContent
+    rawContent,
+    lineEnding
   };
 }
-async function writeVaultFile(vaultPath2, notePath, content, frontmatter) {
-  if (!validatePath(vaultPath2, notePath)) {
-    throw new Error("Invalid path: path traversal not allowed");
+async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEnding = "LF") {
+  const validation = await validatePathSecure(vaultPath2, notePath);
+  if (!validation.valid) {
+    throw new Error(`Invalid path: ${validation.reason}`);
   }
   const fullPath = path.join(vaultPath2, notePath);
-  const output = matter.stringify(content, frontmatter);
+  let output = matter.stringify(content, frontmatter);
+  output = normalizeTrailingNewline(output);
+  output = convertLineEndings(output, lineEnding);
   await fs.writeFile(fullPath, output, "utf-8");
 }
 function removeFromSection(content, section, pattern, mode = "first", useRegex = false) {
@@ -374,10 +492,498 @@ 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 = [
   "daily-notes",
   "daily",
@@ -390,7 +996,7 @@ var DEFAULT_EXCLUDE_FOLDERS = [
   "templates"
 ];
 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) {
@@ -416,8 +1022,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`);
@@ -461,86 +1076,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;
@@ -550,23 +1085,37 @@ 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 };
 }
-function scoreEntity(entityName, contentTokens) {
-  const entityWords = entityName.toLowerCase().split(/\s+/);
+var MAX_ENTITY_LENGTH = 30;
+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;
@@ -584,19 +1133,49 @@ 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) {
-    if (linkedEntities.has(entity.name.toLowerCase())) {
+    const entityName = typeof entity === "string" ? entity : entity.name;
+    if (!entityName)
+      continue;
+    if (entityName.length > MAX_ENTITY_LENGTH) {
       continue;
     }
-    const score = scoreEntity(entity.name, contentTokens);
+    if (linkedEntities.has(entityName.toLowerCase())) {
+      continue;
+    }
+    const score = scoreEntity(entityName, contentTokens, contentStems);
     if (score > 0) {
-      scoredEntities.push({ name: entity.name, score });
+      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 (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);
@@ -613,7 +1192,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",
@@ -631,7 +1210,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 {
@@ -715,7 +1294,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 {
@@ -797,7 +1376,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 {
@@ -883,7 +1462,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");
@@ -939,7 +1518,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 {
@@ -1029,11 +1608,12 @@ function registerTaskTools(server2, vaultPath2) {
       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)"),
       skipWikilinks: z2.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
-      suggestOutgoingLinks: z2.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]] [[Philosophy]]"). Set false to disable.')
+      suggestOutgoingLinks: z2.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]] [[Philosophy]]"). Set false to disable.'),
+      preserveListNesting: z2.boolean().default(true).describe("Preserve indentation when inserting into nested lists. Default: true")
     },
-    async ({ path: notePath, section, task, position, completed, commit, skipWikilinks, suggestOutgoingLinks }) => {
+    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 {
@@ -1069,7 +1649,8 @@ function registerTaskTools(server2, vaultPath2) {
           fileContent,
           sectionBoundary,
           taskLine,
-          position
+          position,
+          { preserveListNesting }
         );
         await writeVaultFile(vaultPath2, notePath, updatedContent, frontmatter);
         let gitCommit;
@@ -1109,7 +1690,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",
@@ -1121,7 +1702,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 {
@@ -1177,7 +1758,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 {
@@ -1234,7 +1815,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",
@@ -1256,7 +1837,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) {
@@ -1269,7 +1850,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;
@@ -1328,7 +1909,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 {
@@ -1374,7 +1955,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",
@@ -1394,7 +1975,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 {
@@ -1502,18 +2083,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.4.1",
+  "version": "0.6.0",
   "description": "Deterministic vault mutations for Obsidian via MCP",
   "type": "module",
   "main": "dist/index.js",