@velvetmonkey/flywheel-crank 0.3.1 → 0.4.0

package/dist/index.js

@@ -103,7 +103,24 @@ function formatContent(content, format) {
       return trimmed;
   }
 }
-function insertInSection(content, section, newContent, position) {
+function detectListIndentation(lines, insertLineIndex, sectionStartLine) {
+  for (let i = insertLineIndex - 1; i >= sectionStartLine; i--) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "")
+      continue;
+    const listMatch = line.match(/^(\s*)[-*+]\s|^(\s*)\d+\.\s|^(\s*)[-*+]\s*\[[ xX]\]/);
+    if (listMatch) {
+      const indent = listMatch[1] || listMatch[2] || listMatch[3] || "";
+      return indent;
+    }
+    if (trimmed.match(/^#+\s/)) {
+      break;
+    }
+  }
+  return "";
+}
+function insertInSection(content, section, newContent, position, options) {
   const lines = content.split("\n");
   const formattedContent = newContent.trim();
   if (position === "prepend") {
@@ -117,7 +134,13 @@ function insertInSection(content, section, newContent, position) {
       }
     }
     if (lastContentLineIdx >= section.contentStartLine && isEmptyPlaceholder(lines[lastContentLineIdx])) {
-      lines[lastContentLineIdx] = formattedContent;
+      if (options?.preserveListNesting) {
+        const indent = detectListIndentation(lines, lastContentLineIdx, section.contentStartLine);
+        const indentedContent = formattedContent.split("\n").map((line) => indent + line).join("\n");
+        lines[lastContentLineIdx] = indentedContent;
+      } else {
+        lines[lastContentLineIdx] = formattedContent;
+      }
     } else {
       let insertLine;
       if (lastContentLineIdx >= section.contentStartLine) {
@@ -130,7 +153,13 @@ function insertInSection(content, section, newContent, position) {
       } else {
         insertLine = section.contentStartLine;
       }
-      lines.splice(insertLine, 0, formattedContent);
+      if (options?.preserveListNesting) {
+        const indent = detectListIndentation(lines, insertLine, section.contentStartLine);
+        const indentedContent = formattedContent.split("\n").map((line) => indent + line).join("\n");
+        lines.splice(insertLine, 0, indentedContent);
+      } else {
+        lines.splice(insertLine, 0, formattedContent);
+      }
     }
   }
   return lines.join("\n");
@@ -431,6 +460,156 @@ 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;
+  let match;
+  while ((match = wikilinkRegex.exec(content)) !== null) {
+    linked.add(match[1].toLowerCase());
+  }
+  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 scoreEntity(entityName, contentTokens) {
+  const entityWords = entityName.toLowerCase().split(/\s+/);
+  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;
+      }
+    }
+  }
+  return score;
+}
+function suggestRelatedLinks(content, options = {}) {
+  const { maxSuggestions = 3, excludeLinked = true } = options;
+  const emptyResult = { suggestions: [], suffix: "" };
+  if (SUGGESTION_PATTERN.test(content)) {
+    return emptyResult;
+  }
+  if (!isEntityIndexReady() || !entityIndex) {
+    return emptyResult;
+  }
+  const entities = getAllEntities(entityIndex);
+  if (entities.length === 0) {
+    return emptyResult;
+  }
+  const contentTokens = tokenizeContent(content);
+  if (contentTokens.length === 0) {
+    return emptyResult;
+  }
+  const linkedEntities = excludeLinked ? extractLinkedEntities(content) : /* @__PURE__ */ new Set();
+  const scoredEntities = [];
+  for (const entity of entities) {
+    if (linkedEntities.has(entity.name.toLowerCase())) {
+      continue;
+    }
+    const score = scoreEntity(entity.name, contentTokens);
+    if (score > 0) {
+      scoredEntities.push({ name: entity.name, score });
+    }
+  }
+  scoredEntities.sort((a, b) => b.score - a.score);
+  const topSuggestions = scoredEntities.slice(0, maxSuggestions).map((e) => e.name);
+  if (topSuggestions.length === 0) {
+    return emptyResult;
+  }
+  const suffix = "\u2192 " + topSuggestions.map((name) => `[[${name}]]`).join(" ");
+  return {
+    suggestions: topSuggestions,
+    suffix
+  };
+}
 
 // src/tools/mutations.ts
 import fs2 from "fs/promises";
@@ -446,9 +625,11 @@ function registerMutationTools(server2, vaultPath2) {
       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)"),
-      skipWikilinks: z.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)")
+      skipWikilinks: z.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
+      preserveListNesting: z.boolean().default(false).describe("If true, detect and preserve the indentation level of surrounding list items"),
+      suggestOutgoingLinks: z.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]] [[Philosophy]]"). Set false to disable.')
     },
-    async ({ path: notePath, section, content, position, format, commit, skipWikilinks }) => {
+    async ({ path: notePath, section, content, position, format, commit, skipWikilinks, preserveListNesting, suggestOutgoingLinks }) => {
       try {
         const fullPath = path4.join(vaultPath2, notePath);
         try {
@@ -471,13 +652,22 @@ function registerMutationTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const { content: wikilinkedContent, wikilinkInfo } = maybeApplyWikilinks(content, skipWikilinks);
-        const formattedContent = formatContent(wikilinkedContent, format);
+        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(content, skipWikilinks);
+        let suggestInfo;
+        if (suggestOutgoingLinks && !skipWikilinks) {
+          const result2 = suggestRelatedLinks(processedContent);
+          if (result2.suffix) {
+            processedContent = processedContent + " " + result2.suffix;
+            suggestInfo = `Suggested: ${result2.suggestions.join(", ")}`;
+          }
+        }
+        const formattedContent = formatContent(processedContent, format);
         const updatedContent = insertInSection(
           fileContent,
           sectionBoundary,
           formattedContent,
-          position
+          position,
+          { preserveListNesting }
         );
         await writeVaultFile(vaultPath2, notePath, updatedContent, frontmatter);
         let gitCommit;
@@ -490,8 +680,9 @@ function registerMutationTools(server2, vaultPath2) {
             gitError = gitResult.error;
           }
         }
-        const preview = formattedContent + (wikilinkInfo ? `
-(${wikilinkInfo})` : "");
+        const infoLines = [wikilinkInfo, suggestInfo].filter(Boolean);
+        const preview = formattedContent + (infoLines.length > 0 ? `
+(${infoLines.join("; ")})` : "");
         const result = {
           success: true,
           message: `Added content to section "${sectionBoundary.name}" in ${notePath}`,
@@ -601,9 +792,10 @@ function registerMutationTools(server2, vaultPath2) {
       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)"),
-      skipWikilinks: z.boolean().default(false).describe("If true, skip auto-wikilink application on replacement text")
+      skipWikilinks: z.boolean().default(false).describe("If true, skip auto-wikilink application on replacement text"),
+      suggestOutgoingLinks: z.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]] [[Philosophy]]"). Set false to disable.')
     },
-    async ({ path: notePath, section, search, replacement, mode, useRegex, commit, skipWikilinks }) => {
+    async ({ path: notePath, section, search, replacement, mode, useRegex, commit, skipWikilinks, suggestOutgoingLinks }) => {
       try {
         const fullPath = path4.join(vaultPath2, notePath);
         try {
@@ -626,12 +818,20 @@ function registerMutationTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const { content: wikilinkedReplacement, wikilinkInfo } = maybeApplyWikilinks(replacement, skipWikilinks);
+        let { content: processedReplacement, wikilinkInfo } = maybeApplyWikilinks(replacement, skipWikilinks);
+        let suggestInfo;
+        if (suggestOutgoingLinks && !skipWikilinks) {
+          const result2 = suggestRelatedLinks(processedReplacement);
+          if (result2.suffix) {
+            processedReplacement = processedReplacement + " " + result2.suffix;
+            suggestInfo = `Suggested: ${result2.suggestions.join(", ")}`;
+          }
+        }
         const replaceResult = replaceInSection(
           fileContent,
           sectionBoundary,
           search,
-          wikilinkedReplacement,
+          processedReplacement,
           mode,
           useRegex
         );
@@ -828,9 +1028,10 @@ function registerTaskTools(server2, vaultPath2) {
       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)"),
-      skipWikilinks: z2.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)")
+      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.')
     },
-    async ({ path: notePath, section, task, position, completed, commit, skipWikilinks }) => {
+    async ({ path: notePath, section, task, position, completed, commit, skipWikilinks, suggestOutgoingLinks }) => {
       try {
         const fullPath = path5.join(vaultPath2, notePath);
         try {
@@ -853,9 +1054,17 @@ function registerTaskTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const { content: wikilinkedTask, wikilinkInfo } = maybeApplyWikilinks(task.trim(), skipWikilinks);
+        let { content: processedTask, wikilinkInfo } = maybeApplyWikilinks(task.trim(), skipWikilinks);
+        let suggestInfo;
+        if (suggestOutgoingLinks && !skipWikilinks) {
+          const result2 = suggestRelatedLinks(processedTask);
+          if (result2.suffix) {
+            processedTask = processedTask + " " + result2.suffix;
+            suggestInfo = `Suggested: ${result2.suggestions.join(", ")}`;
+          }
+        }
         const checkbox = completed ? "[x]" : "[ ]";
-        const taskLine = `- ${checkbox} ${wikilinkedTask}`;
+        const taskLine = `- ${checkbox} ${processedTask}`;
         const updatedContent = insertInSection(
           fileContent,
           sectionBoundary,
@@ -873,12 +1082,13 @@ function registerTaskTools(server2, vaultPath2) {
             gitError = gitResult.error;
           }
         }
+        const infoLines = [wikilinkInfo, suggestInfo].filter(Boolean);
         const result = {
           success: true,
           message: `Added task to section "${sectionBoundary.name}" in ${notePath}`,
           path: notePath,
-          preview: taskLine + (wikilinkInfo ? `
-(${wikilinkInfo})` : ""),
+          preview: taskLine + (infoLines.length > 0 ? `
+(${infoLines.join("; ")})` : ""),
           gitCommit,
           gitError
         };

package/package.json

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