@velvetmonkey/flywheel-memory 2.0.9 → 2.0.10

package/dist/index.js

@@ -5023,6 +5023,82 @@ function getLinkPath(index, fromPath, toPath, maxDepth = 10) {
   }
   return { exists: false, path: [], length: -1 };
 }
+function getWeightedLinkPath(index, fromPath, toPath, maxDepth = 10) {
+  const from = index.notes.has(fromPath) ? fromPath : resolveTarget(index, fromPath);
+  const to = index.notes.has(toPath) ? toPath : resolveTarget(index, toPath);
+  if (!from || !to) {
+    return { exists: false, path: [], length: -1, total_weight: 0, weights: [] };
+  }
+  if (from === to) {
+    return { exists: true, path: [from], length: 0, total_weight: 0, weights: [] };
+  }
+  const hubNotes = findHubNotes(index, 0);
+  const connectionCounts = /* @__PURE__ */ new Map();
+  for (const hub of hubNotes) {
+    connectionCounts.set(hub.path, hub.total_connections);
+  }
+  const dist = /* @__PURE__ */ new Map();
+  const prev = /* @__PURE__ */ new Map();
+  const depthMap = /* @__PURE__ */ new Map();
+  dist.set(from, 0);
+  depthMap.set(from, 0);
+  const pq = [{ node: from, cost: 0 }];
+  const visited = /* @__PURE__ */ new Set();
+  while (pq.length > 0) {
+    const { node: current, cost: currentCost } = pq.shift();
+    if (current === to) break;
+    if (visited.has(current)) continue;
+    visited.add(current);
+    const currentDepth = depthMap.get(current) ?? 0;
+    if (currentDepth >= maxDepth) continue;
+    const note = index.notes.get(current);
+    if (!note) continue;
+    for (const link of note.outlinks) {
+      const targetPath = resolveTarget(index, link.target);
+      if (!targetPath || visited.has(targetPath)) continue;
+      const strength = getConnectionStrength(index, current, targetPath);
+      const baseWeight = 1 / (1 + strength.score);
+      const targetConnections = connectionCounts.get(targetPath) ?? 0;
+      const hubPenalty = targetConnections > 0 ? 1 + Math.log2(targetConnections) : 1;
+      const edgeWeight = baseWeight * hubPenalty;
+      const newDist = currentCost + edgeWeight;
+      const existingDist = dist.get(targetPath);
+      if (existingDist === void 0 || newDist < existingDist) {
+        dist.set(targetPath, newDist);
+        prev.set(targetPath, current);
+        depthMap.set(targetPath, currentDepth + 1);
+        const entry = { node: targetPath, cost: newDist };
+        const insertIdx = pq.findIndex((e) => e.cost > newDist);
+        if (insertIdx === -1) {
+          pq.push(entry);
+        } else {
+          pq.splice(insertIdx, 0, entry);
+        }
+      }
+    }
+  }
+  if (!dist.has(to)) {
+    return { exists: false, path: [], length: -1, total_weight: 0, weights: [] };
+  }
+  const resultPath = [];
+  let node = to;
+  while (node) {
+    resultPath.unshift(node);
+    node = prev.get(node);
+  }
+  const weights = [];
+  for (let i = 0; i < resultPath.length - 1; i++) {
+    const edgeDist = (dist.get(resultPath[i + 1]) ?? 0) - (dist.get(resultPath[i]) ?? 0);
+    weights.push(Math.round(edgeDist * 1e3) / 1e3);
+  }
+  return {
+    exists: true,
+    path: resultPath,
+    length: resultPath.length - 1,
+    total_weight: Math.round((dist.get(to) ?? 0) * 1e3) / 1e3,
+    weights
+  };
+}
 function getCommonNeighbors(index, noteAPath, noteBPath) {
   const noteA = index.notes.get(noteAPath);
   const noteB = index.notes.get(noteBPath);
@@ -6103,15 +6179,20 @@ function matchesFrontmatter(note, where) {
   }
   return true;
 }
-function hasTag(note, tag) {
+function hasTag(note, tag, includeChildren = false) {
   const normalizedTag = tag.replace(/^#/, "").toLowerCase();
-  return note.tags.some((t) => t.toLowerCase() === normalizedTag);
+  return note.tags.some((t) => {
+    const normalizedNoteTag = t.toLowerCase();
+    if (normalizedNoteTag === normalizedTag) return true;
+    if (includeChildren && normalizedNoteTag.startsWith(normalizedTag + "/")) return true;
+    return false;
+  });
 }
-function hasAnyTag(note, tags) {
-  return tags.some((tag) => hasTag(note, tag));
+function hasAnyTag(note, tags, includeChildren = false) {
+  return tags.some((tag) => hasTag(note, tag, includeChildren));
 }
-function hasAllTags(note, tags) {
-  return tags.every((tag) => hasTag(note, tag));
+function hasAllTags(note, tags, includeChildren = false) {
+  return tags.every((tag) => hasTag(note, tag, includeChildren));
 }
 function inFolder(note, folder) {
   const normalizedFolder = folder.endsWith("/") ? folder : folder + "/";
@@ -6150,6 +6231,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
       has_tag: z4.string().optional().describe("Filter to notes with this tag"),
       has_any_tag: z4.array(z4.string()).optional().describe("Filter to notes with any of these tags"),
       has_all_tags: z4.array(z4.string()).optional().describe("Filter to notes with all of these tags"),
+      include_children: z4.boolean().default(false).describe('When true, tag filters also match child tags (e.g., has_tag: "project" also matches "project/active")'),
       folder: z4.string().optional().describe("Limit to notes in this folder"),
       title_contains: z4.string().optional().describe("Filter to notes whose title contains this text (case-insensitive)"),
       // Date filters (absorbs temporal tools)
@@ -6163,7 +6245,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
       // Pagination
       limit: z4.number().default(20).describe("Maximum number of results to return")
     },
-    async ({ query, scope, where, has_tag, has_any_tag, has_all_tags, folder, title_contains, modified_after, modified_before, sort_by, order, prefix, limit: requestedLimit }) => {
+    async ({ query, scope, where, has_tag, has_any_tag, has_all_tags, include_children, folder, title_contains, modified_after, modified_before, sort_by, order, prefix, limit: requestedLimit }) => {
       const limit = Math.min(requestedLimit ?? 20, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
@@ -6189,13 +6271,13 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
           matchingNotes = matchingNotes.filter((note) => matchesFrontmatter(note, where));
         }
         if (has_tag) {
-          matchingNotes = matchingNotes.filter((note) => hasTag(note, has_tag));
+          matchingNotes = matchingNotes.filter((note) => hasTag(note, has_tag, include_children));
         }
         if (has_any_tag && has_any_tag.length > 0) {
-          matchingNotes = matchingNotes.filter((note) => hasAnyTag(note, has_any_tag));
+          matchingNotes = matchingNotes.filter((note) => hasAnyTag(note, has_any_tag, include_children));
         }
         if (has_all_tags && has_all_tags.length > 0) {
-          matchingNotes = matchingNotes.filter((note) => hasAllTags(note, has_all_tags));
+          matchingNotes = matchingNotes.filter((note) => hasAllTags(note, has_all_tags, include_children));
         }
         if (folder) {
           matchingNotes = matchingNotes.filter((note) => inFolder(note, folder));
@@ -7136,16 +7218,17 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
     "get_link_path",
     {
       title: "Get Link Path",
-      description: "Find the shortest path of links between two notes.",
+      description: "Find the shortest path of links between two notes. Use weighted=true to penalize hub nodes for more meaningful paths.",
       inputSchema: {
         from: z6.string().describe("Starting note path"),
         to: z6.string().describe("Target note path"),
-        max_depth: z6.coerce.number().default(10).describe("Maximum path length to search")
+        max_depth: z6.coerce.number().default(10).describe("Maximum path length to search"),
+        weighted: z6.boolean().default(false).describe("Use weighted path-finding that penalizes hub nodes for more meaningful paths")
       }
     },
-    async ({ from, to, max_depth }) => {
+    async ({ from, to, max_depth, weighted }) => {
       const index = getIndex();
-      const result = getLinkPath(index, from, to, max_depth);
+      const result = weighted ? getWeightedLinkPath(index, from, to, max_depth) : getLinkPath(index, from, to, max_depth);
       return {
         content: [{ type: "text", text: JSON.stringify({
           from,
@@ -9503,6 +9586,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
     {
       path: z14.string().describe('Vault-relative path for the new note (e.g., "daily-notes/2026-01-28.md")'),
       content: z14.string().default("").describe("Initial content for the note"),
+      template: z14.string().optional().describe('Vault-relative path to a template file (e.g., "templates/person.md"). Template variables {{date}} and {{title}} are substituted. Template frontmatter is merged with the frontmatter parameter (explicit values take precedence).'),
       frontmatter: z14.record(z14.any()).default({}).describe("Frontmatter fields (JSON object)"),
       overwrite: z14.boolean().default(false).describe("If true, overwrite existing file"),
       commit: z14.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
@@ -9512,7 +9596,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
       agent_id: z14.string().optional().describe("Agent identifier for multi-agent scoping"),
       session_id: z14.string().optional().describe("Session identifier for conversation scoping")
     },
-    async ({ path: notePath, content, frontmatter, overwrite, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, agent_id, session_id }) => {
+    async ({ path: notePath, content, template, frontmatter, overwrite, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, agent_id, session_id }) => {
       try {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
@@ -9524,9 +9608,29 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
         }
         const dir = path18.dirname(fullPath);
         await fs18.mkdir(dir, { recursive: true });
+        let effectiveContent = content;
+        let effectiveFrontmatter = frontmatter;
+        if (template) {
+          const templatePath = path18.join(vaultPath2, template);
+          try {
+            const raw = await fs18.readFile(templatePath, "utf-8");
+            const matter8 = (await import("gray-matter")).default;
+            const parsed = matter8(raw);
+            const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+            const title = path18.basename(notePath, ".md");
+            let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
+            if (content) {
+              templateContent = templateContent.trimEnd() + "\n\n" + content;
+            }
+            effectiveContent = templateContent;
+            effectiveFrontmatter = { ...parsed.data || {}, ...frontmatter };
+          } catch {
+            return formatMcpResult(errorResult(notePath, `Template not found: ${template}`));
+          }
+        }
         const warnings = [];
         const noteName = path18.basename(notePath, ".md");
-        const existingAliases = Array.isArray(frontmatter?.aliases) ? frontmatter.aliases.filter((a) => typeof a === "string") : [];
+        const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
           warnings.push({
@@ -9550,7 +9654,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
             suggestion: `This may cause ambiguous wikilink resolution`
           });
         }
-        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(content, skipWikilinks, notePath);
+        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(effectiveContent, skipWikilinks, notePath);
         let suggestInfo;
         if (suggestOutgoingLinks && !skipWikilinks) {
           const result = suggestRelatedLinks(processedContent, { maxSuggestions, notePath });
@@ -9559,21 +9663,21 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
             suggestInfo = `Suggested: ${result.suggestions.join(", ")}`;
           }
         }
-        let finalFrontmatter = frontmatter;
+        let finalFrontmatter = effectiveFrontmatter;
         if (agent_id || session_id) {
-          finalFrontmatter = injectMutationMetadata(frontmatter, { agent_id, session_id });
+          finalFrontmatter = injectMutationMetadata(effectiveFrontmatter, { agent_id, session_id });
         }
         await writeVaultFile(vaultPath2, notePath, processedContent, finalFrontmatter);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Create]");
         const infoLines = [wikilinkInfo, suggestInfo].filter(Boolean);
         const previewLines = [
-          `Frontmatter fields: ${Object.keys(frontmatter).join(", ") || "none"}`,
+          `Frontmatter fields: ${Object.keys(effectiveFrontmatter).join(", ") || "none"}`,
           `Content length: ${processedContent.length} chars`
         ];
         if (infoLines.length > 0) {
           previewLines.push(`(${infoLines.join("; ")})`);
         }
-        const hasAliases = frontmatter && "aliases" in frontmatter;
+        const hasAliases = effectiveFrontmatter && "aliases" in effectiveFrontmatter;
         if (!hasAliases) {
           const aliasSuggestions = suggestAliases(noteName, existingAliases);
           if (aliasSuggestions.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.9",
+  "version": "2.0.10",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. 36 tools for search, backlinks, graph queries, and mutations.",
   "type": "module",
   "main": "dist/index.js",
@@ -50,7 +50,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.9",
+    "@velvetmonkey/vault-core": "^2.0.10",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",