obsidian-mcp-brain 0.2.0

package/lib/sections.mjs

@@ -0,0 +1,196 @@
+// Pure functions for heading-section replacement and checkbox toggling within note content.
+// All functions take and return strings; no filesystem I/O.
+
+const HEADING_RE = /^(#{1,6})\s+(.*)$/;
+const CHECKBOX_RE = /^\s*[-*]\s+\[([ xX])\]\s+(.*)$/;
+const FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
+
+/**
+ * Computes which lines fall inside a fenced code block (``` or ~~~, optionally indented
+ * up to 3 spaces), so heading/checkbox parsing can skip them — otherwise a code sample
+ * containing e.g. `# comment` or `- [ ] text` would be misread as real note structure.
+ * @returns {boolean[]} true for each line index that is part of a fence (opening/closing
+ *   fence lines included, since neither is itself a heading or checkbox line).
+ */
+function computeFenceMask(lines) {
+  const mask = new Array(lines.length).fill(false);
+  let fenceChar = null;
+  let fenceLen = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const m = FENCE_RE.exec(lines[i]);
+    if (fenceChar) {
+      mask[i] = true;
+      if (m && m[1][0] === fenceChar && m[1].length >= fenceLen) {
+        fenceChar = null;
+        fenceLen = 0;
+      }
+    } else if (m) {
+      fenceChar = m[1][0];
+      fenceLen = m[1].length;
+      mask[i] = true;
+    }
+  }
+  return mask;
+}
+
+/**
+ * Parses all ATX headings (# through ######) in content, ignoring lines inside fenced
+ * code blocks. Setext-style (===/---) headings are not recognised.
+ * @returns {Array<{text: string, level: number, line: number, bodyEndLine: number}>}
+ *   line is 1-based. bodyEndLine is the 1-based last line belonging to this heading's
+ *   section — everything up to (but not including) the next heading of the same or
+ *   shallower level, or the last line of the file if there is none.
+ */
+export function findHeadings(content) {
+  const lines = content.split('\n');
+  const inFence = computeFenceMask(lines);
+  const headings = [];
+  lines.forEach((line, i) => {
+    if (inFence[i]) return;
+    const m = HEADING_RE.exec(line);
+    if (m) headings.push({ text: m[2].trim(), level: m[1].length, line: i + 1 });
+  });
+  return headings.map((h, idx) => {
+    let bodyEndLine = lines.length;
+    for (let j = idx + 1; j < headings.length; j++) {
+      if (headings[j].level <= h.level) {
+        bodyEndLine = headings[j].line - 1;
+        break;
+      }
+    }
+    return { ...h, bodyEndLine };
+  });
+}
+
+/**
+ * Constructs an error message for an ambiguous match, listing all matches and suggesting
+ * the user retry with an occurrence parameter to disambiguate.
+ * @param {string} kind — "heading" or "task" (used in error message)
+ * @param {string} matchText — the search term that matched multiple times
+ * @param {Array} matches — array of matching objects
+ * @param {Function} describeMatch — function that takes a match and returns a descriptive string
+ * @returns {Error} an error with formatted message describing all matches
+ */
+function ambiguityError(kind, matchText, matches, describeMatch) {
+  const list = matches.map((m, i) => `${i + 1}. ${describeMatch(m)}`).join('\n');
+  return new Error(
+    `Ambiguous ${kind} "${matchText}" — ${matches.length} matches:\n${list}\nRetry with an occurrence parameter (1-${matches.length}).`,
+  );
+}
+
+/**
+ * Selects a match from an array using a 1-based occurrence index, with validation and
+ * fallback to the first match if occurrence is undefined. Throws if occurrence is not a
+ * positive integer or if the requested occurrence index is out of bounds.
+ * @param {Array} matches — array of matches to select from
+ * @param {number} occurrence — 1-based index into matches; undefined defaults to the first match
+ * @returns {*} the selected match object
+ * @throws {Error} if occurrence is not a positive integer, or if index is out of bounds
+ */
+function pickMatch(matches, occurrence) {
+  if (occurrence !== undefined && !(Number.isInteger(occurrence) && occurrence >= 1)) {
+    throw new Error(`Invalid occurrence ${occurrence}: must be a positive integer`);
+  }
+  const idx = occurrence !== undefined ? occurrence - 1 : 0;
+  const match = matches[idx];
+  if (!match) {
+    throw new Error(
+      `Invalid occurrence ${occurrence}: ${matches.length} match(es) available`,
+    );
+  }
+  return match;
+}
+
+/**
+ * Replaces the content under the heading matching `heading` (exact text) with `newBody`,
+ * leaving the heading line itself untouched. The replaced span runs from immediately after
+ * the heading line up to (but not including) the next heading of the same or shallower
+ * level, or end of file.
+ *
+ * Throws if `heading` matches no heading, or matches more than one and no `occurrence`
+ * (1-based) is given to disambiguate.
+ */
+export function replaceSection(content, heading, newBody, occurrence) {
+  const headings = findHeadings(content);
+  const matches = headings.filter(h => h.text === heading);
+  if (matches.length === 0) {
+    throw new Error(`Heading not found: ${heading}`);
+  }
+  if (matches.length > 1 && occurrence === undefined) {
+    throw ambiguityError('heading', heading, matches, m => `line ${m.line} (level ${m.level})`);
+  }
+  const match = pickMatch(matches, occurrence);
+
+  const lines = content.split('\n');
+  const before = lines.slice(0, match.line);
+  const after = lines.slice(match.bodyEndLine);
+  return [...before, ...newBody.split('\n'), ...after].join('\n');
+}
+
+/**
+ * Removes the heading matching `heading` (exact text) along with its entire body — the
+ * heading line itself plus everything up to (but not including) the next heading of the
+ * same or shallower level, or end of file. Unlike replaceSection, nothing is left behind
+ * in the heading's place.
+ *
+ * Throws if `heading` matches no heading, or matches more than one and no `occurrence`
+ * (1-based) is given to disambiguate.
+ */
+export function deleteSection(content, heading, occurrence) {
+  const headings = findHeadings(content);
+  const matches = headings.filter(h => h.text === heading);
+  if (matches.length === 0) {
+    throw new Error(`Heading not found: ${heading}`);
+  }
+  if (matches.length > 1 && occurrence === undefined) {
+    throw ambiguityError('heading', heading, matches, m => `line ${m.line} (level ${m.level})`);
+  }
+  const match = pickMatch(matches, occurrence);
+
+  const lines = content.split('\n');
+  const before = lines.slice(0, match.line - 1);
+  const after = lines.slice(match.bodyEndLine);
+  return [...before, ...after].join('\n');
+}
+
+/**
+ * Parses all Markdown checkbox list items (`- [ ]`/`- [x]`, `*` bullets also accepted),
+ * ignoring lines inside fenced code blocks.
+ * @returns {Array<{text: string, checked: boolean, line: number}>} line is 1-based.
+ */
+export function findCheckboxes(content) {
+  const lines = content.split('\n');
+  const inFence = computeFenceMask(lines);
+  const boxes = [];
+  lines.forEach((line, i) => {
+    if (inFence[i]) return;
+    const m = CHECKBOX_RE.exec(line);
+    if (m) boxes.push({ text: m[2].trim(), checked: m[1].toLowerCase() === 'x', line: i + 1 });
+  });
+  return boxes;
+}
+
+/**
+ * Sets the checked state of the checkbox line whose text (after the marker) exactly
+ * matches `taskText`. If `checked` is omitted, the box's current state is flipped;
+ * otherwise it's set to that explicit boolean.
+ *
+ * Throws if `taskText` matches no checkbox, or matches more than one and no `occurrence`
+ * (1-based) is given to disambiguate.
+ */
+export function toggleCheckbox(content, taskText, checked, occurrence) {
+  const boxes = findCheckboxes(content);
+  const matches = boxes.filter(b => b.text === taskText);
+  if (matches.length === 0) {
+    throw new Error(`Checkbox not found: ${taskText}`);
+  }
+  if (matches.length > 1 && occurrence === undefined) {
+    throw ambiguityError('task', taskText, matches, m => `line ${m.line} (currently ${m.checked ? 'checked' : 'unchecked'})`);
+  }
+  const match = pickMatch(matches, occurrence);
+
+  const newChecked = checked === undefined ? !match.checked : checked;
+  const lines = content.split('\n');
+  lines[match.line - 1] = lines[match.line - 1].replace(/\[[ xX]\]/, `[${newChecked ? 'x' : ' '}]`);
+  return lines.join('\n');
+}

package/lib/utils.mjs

@@ -0,0 +1,8 @@
+// Shared utilities for lib modules.
+
+/**
+ * Escapes regex metacharacters in a string.
+ */
+export function escRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/lib/vault.mjs

@@ -0,0 +1,359 @@
+// Filesystem operations for vault notes.
+// Callers are responsible for path validation and access control.
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { rewriteLinks, extractReferences } from './wikilinks.mjs';
+import { isDenied } from './access.mjs';
+
+/**
+ * Recursively walks vault directories, calling callback for each markdown file.
+ * Skips directories and files starting with '.' (e.g., .trash, .obsidian, .git).
+ * @param {string} dir - Directory to walk
+ * @param {Function} cb - Async callback receiving absolute path of each .md file
+ */
+export async function walkVault(dir, cb) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue; // skip .trash, .obsidian, .git, etc.
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkVault(full, cb);
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      await cb(full);
+    }
+  }
+}
+
+/**
+ * Recursively walks vault directories, calling callback for every file regardless of
+ * extension. Skips directories and files starting with '.' (e.g., .trash, .obsidian, .git).
+ * Unlike walkVault, this visits binary files too — needed since a wikilink can resolve to one.
+ * @param {string} dir - Directory to walk
+ * @param {Function} cb - Async callback receiving absolute path of each file
+ */
+export async function walkAllFiles(dir, cb) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue; // skip .trash, .obsidian, .git, etc.
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkAllFiles(full, cb);
+    } else if (entry.isFile()) {
+      await cb(full);
+    }
+  }
+}
+
+/**
+ * Computes the match key for a vault-relative path: the .md extension is stripped for
+ * notes (so links match their extensionless target), kept for everything else (so embeds,
+ * which reference the full filename, match exactly).
+ */
+function matchKeyFor(relPath) {
+  return relPath.endsWith('.md') ? relPath.replace(/\.md$/, '') : relPath;
+}
+
+/**
+ * Finds every note that links to or embeds the given target file (a note or binary file),
+ * matching by the target's match key or bare basename — the same rule rewriteLinks uses.
+ * Basename matching can over-attribute when the basename is ambiguous elsewhere in the
+ * vault (e.g. a `[[sauce]]` link is reported against every file named "sauce", the same
+ * limitation rewriteLinks/moveNote already have) — use resolve-wikilink first to check
+ * whether a target is unambiguous.
+ * @param {string} vaultPath - Absolute path to vault root
+ * @param {string} targetRelPath - Vault-relative path of the target file
+ * @param {string[]} denyPaths - Vault-relative paths excluded from the results
+ * @returns {Promise<string[]>} Sorted vault-relative paths of notes referencing the target
+ */
+export async function findBacklinks(vaultPath, targetRelPath, denyPaths) {
+  const matchKey = matchKeyFor(targetRelPath);
+  const basename = path.posix.basename(matchKey);
+  const results = [];
+
+  await walkVault(vaultPath, async filePath => {
+    const rel = path.relative(vaultPath, filePath);
+    if (isDenied(denyPaths, rel)) return;
+    if (rel === targetRelPath) return; // a note doesn't "backlink" to itself
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch {
+      return;
+    }
+    const refs = extractReferences(content);
+    if (refs.some(r => r.target === matchKey || r.target === basename)) {
+      results.push(rel);
+    }
+  });
+
+  results.sort();
+  return results;
+}
+
+/**
+ * Resolves a raw wikilink target string (as passed to rewriteLinks — no [[ ]], heading,
+ * or alias) to the vault file(s) whose match key or basename equals it. Zero results
+ * means the target doesn't resolve; more than one means it's ambiguous.
+ * @param {string} vaultPath - Absolute path to vault root
+ * @param {string} target - Raw wikilink target string
+ * @param {string[]} denyPaths - Vault-relative paths excluded from the results
+ * @returns {Promise<string[]>} Sorted vault-relative paths matching the target
+ */
+export async function resolveWikilink(vaultPath, target, denyPaths) {
+  const results = [];
+
+  await walkAllFiles(vaultPath, async filePath => {
+    const rel = path.relative(vaultPath, filePath);
+    if (isDenied(denyPaths, rel)) return;
+    const matchKey = matchKeyFor(rel);
+    const basename = path.posix.basename(matchKey);
+    if (matchKey === target || basename === target) {
+      results.push(rel);
+    }
+  });
+
+  results.sort();
+  return results;
+}
+
+/**
+ * Reads note content from disk.
+ */
+export async function readNote(absPath) {
+  return fs.readFile(absPath, 'utf8');
+}
+
+/**
+ * Writes note content to disk, creating parent directories as needed.
+ */
+export async function writeNote(absPath, content) {
+  await fs.mkdir(path.dirname(absPath), { recursive: true });
+  await fs.writeFile(absPath, content, 'utf8');
+}
+
+/**
+ * Deletes a note permanently or moves to .trash. On filename collision, appends timestamp suffix.
+ * @param {string} absPath - Absolute path to note
+ * @param {boolean} permanent - If true, permanently delete; if false, move to .trash
+ * @param {string} vaultPath - Absolute path to vault root
+ */
+export async function deleteNote(absPath, permanent, vaultPath) {
+  if (permanent) {
+    await fs.unlink(absPath);
+  } else {
+    const trashDir = path.join(vaultPath, '.trash');
+    await fs.mkdir(trashDir, { recursive: true });
+    const baseName = path.basename(absPath, '.md');
+    let dest = path.join(trashDir, path.basename(absPath));
+    try {
+      await fs.access(dest);
+      // Collision — suffix with timestamp to avoid silent overwrite
+      dest = path.join(trashDir, `${baseName}_${Date.now()}.md`);
+    } catch {
+      // ENOENT: destination free, use it
+    }
+    await fs.rename(absPath, dest);
+  }
+}
+
+/**
+ * Moves note from srcAbs to dstAbs, then rewrites all vault-wide wikilinks to the old path.
+ * Throws if destination already exists. Updates are best-effort; fails silently for inaccessible notes.
+ * @param {string} vaultPath - Absolute path to vault root
+ * @param {string} srcAbs - Absolute path to source note
+ * @param {string} dstAbs - Absolute path to destination note
+ * @param {string[]} denyPaths - Vault-relative paths to exclude from rewriting
+ */
+export async function moveNote(vaultPath, srcAbs, dstAbs, denyPaths) {
+  // Guard against silently clobbering an existing note
+  try {
+    await fs.access(dstAbs);
+    throw new Error(`Destination already exists: ${path.relative(vaultPath, dstAbs)}`);
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+
+  await fs.mkdir(path.dirname(dstAbs), { recursive: true });
+
+  const oldRel = path.relative(vaultPath, srcAbs).replace(/\.md$/, '');
+  const newRel = path.relative(vaultPath, dstAbs).replace(/\.md$/, '');
+
+  await fs.rename(srcAbs, dstAbs);
+
+  // Rewrite links in every other vault note
+  await walkVault(vaultPath, async filePath => {
+    if (filePath === dstAbs) return;
+    const rel = path.relative(vaultPath, filePath);
+    if (isDenied(denyPaths, rel)) return;
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch {
+      return;
+    }
+    const updated = rewriteLinks(content, oldRel, newRel);
+    if (updated !== content) {
+      try {
+        await fs.writeFile(filePath, updated, 'utf8');
+      } catch {
+        return; // best-effort: log failure without aborting remaining rewrites
+      }
+    }
+  });
+}
+
+/**
+ * Reads binary file content from disk.
+ */
+export async function readBinaryFile(absPath) {
+  return fs.readFile(absPath);
+}
+
+/**
+ * Writes binary content to disk, creating parent directories as needed.
+ * @param {string} absPath - Absolute path to write
+ * @param {Buffer} buffer - Binary content
+ */
+export async function writeBinaryFile(absPath, buffer) {
+  await fs.mkdir(path.dirname(absPath), { recursive: true });
+  await fs.writeFile(absPath, buffer);
+}
+
+/**
+ * Deletes a binary file permanently or moves to .trash. On filename collision, appends a
+ * timestamp suffix before the extension (unlike deleteNote, the extension varies per file).
+ * @param {string} absPath - Absolute path to binary file
+ * @param {boolean} permanent - If true, permanently delete; if false, move to .trash
+ * @param {string} vaultPath - Absolute path to vault root
+ */
+export async function deleteBinaryFile(absPath, permanent, vaultPath) {
+  if (permanent) {
+    await fs.unlink(absPath);
+  } else {
+    const trashDir = path.join(vaultPath, '.trash');
+    await fs.mkdir(trashDir, { recursive: true });
+    const ext = path.extname(absPath);
+    const baseName = path.basename(absPath, ext);
+    let dest = path.join(trashDir, path.basename(absPath));
+    try {
+      await fs.access(dest);
+      // Collision — suffix with timestamp to avoid silent overwrite
+      dest = path.join(trashDir, `${baseName}_${Date.now()}${ext}`);
+    } catch {
+      // ENOENT: destination free, use it
+    }
+    await fs.rename(absPath, dest);
+  }
+}
+
+/**
+ * Moves a binary file from srcAbs to dstAbs, then rewrites all vault-wide wikilink embeds
+ * pointing at the old path. Throws if destination already exists.
+ *
+ * Unlike moveNote, the filename (including extension) is kept intact when rewriting, since
+ * embeds reference binary files by their full filename rather than an extensionless basename.
+ * @param {string} vaultPath - Absolute path to vault root
+ * @param {string} srcAbs - Absolute path to source file
+ * @param {string} dstAbs - Absolute path to destination file
+ * @param {string[]} denyPaths - Vault-relative paths to exclude from rewriting
+ */
+export async function moveBinaryFile(vaultPath, srcAbs, dstAbs, denyPaths) {
+  // Guard against silently clobbering an existing file
+  try {
+    await fs.access(dstAbs);
+    throw new Error(`Destination already exists: ${path.relative(vaultPath, dstAbs)}`);
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+
+  await fs.mkdir(path.dirname(dstAbs), { recursive: true });
+
+  const oldRel = path.relative(vaultPath, srcAbs);
+  const newRel = path.relative(vaultPath, dstAbs);
+
+  await fs.rename(srcAbs, dstAbs);
+
+  // Rewrite embeds in every vault note (walkVault only visits .md files, so the moved
+  // binary file itself is never read as text)
+  await walkVault(vaultPath, async filePath => {
+    const rel = path.relative(vaultPath, filePath);
+    if (isDenied(denyPaths, rel)) return;
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch {
+      return;
+    }
+    const updated = rewriteLinks(content, oldRel, newRel);
+    if (updated !== content) {
+      try {
+        await fs.writeFile(filePath, updated, 'utf8');
+      } catch {
+        return; // best-effort: log failure without aborting remaining rewrites
+      }
+    }
+  });
+}
+
+/**
+ * Searches note content for query (case-insensitive).
+ * @returns {Promise<Array<{path: string, matches: Array<{line: number, text: string}>}>>} Results sorted by path.
+ */
+export async function searchContent(vaultPath, query, scopeDir, denyPaths) {
+  const lower = query.toLowerCase();
+  const results = [];
+
+  await walkVault(scopeDir, async filePath => {
+    const rel = path.relative(vaultPath, filePath);
+    if (isDenied(denyPaths, rel)) return;
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch {
+      return;
+    }
+    const matches = content
+      .split('\n')
+      .reduce((acc, text, i) => {
+        if (text.toLowerCase().includes(lower)) acc.push({ line: i + 1, text });
+        return acc;
+      }, []);
+    if (matches.length > 0) {
+      results.push({ path: rel, matches });
+    }
+  });
+
+  results.sort((a, b) => a.path.localeCompare(b.path));
+  return results;
+}
+
+/**
+ * Searches note filenames and vault-relative paths for query (case-insensitive).
+ * @returns {Promise<string[]>} Vault-relative paths, sorted.
+ */
+export async function searchFilename(vaultPath, query, scopeDir, denyPaths) {
+  const lower = query.toLowerCase();
+  const results = [];
+
+  await walkVault(scopeDir, async filePath => {
+    const rel = path.relative(vaultPath, filePath);
+    if (isDenied(denyPaths, rel)) return;
+    if (rel.toLowerCase().includes(lower)) {
+      results.push(rel);
+    }
+  });
+
+  results.sort();
+  return results;
+}

package/lib/wikilinks.mjs

@@ -0,0 +1,77 @@
+// Pure functions for Obsidian wikilink parsing and rewriting.
+// All functions take and return strings; no filesystem I/O.
+
+import path from 'node:path';
+import { escRe } from './utils.mjs';
+
+/**
+ * Parses all wikilinks in content and returns their components.
+ * Handles format: [[target#heading|alias]] (heading and alias optional).
+ * @returns {Array<{target: string, heading: string, alias: string}>} Parsed wikilinks.
+ */
+export function extractLinks(content) {
+  const re = /\[\[([^\]#|]+?)(?:#([^\]|]*))?(?:\|([^\]]*))?\]\]/g;
+  const links = [];
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    links.push({
+      target: m[1].trim(),
+      heading: m[2] ?? '',
+      alias: m[3] ?? '',
+    });
+  }
+  return links;
+}
+
+/**
+ * Parses all wikilinks and embeds in content and returns their components.
+ * Handles both [[target#heading|alias]] and ![[target#heading|alias]] (embed), heading
+ * and alias optional. Unlike extractLinks, this also reports whether each match was an
+ * embed — used by backlink/resolution lookups that must treat both forms as a reference.
+ * @returns {Array<{target: string, heading: string, alias: string, embed: boolean}>}
+ */
+export function extractReferences(content) {
+  const re = /(!)?\[\[([^\]#|]+?)(?:#([^\]|]*))?(?:\|([^\]]*))?\]\]/g;
+  const refs = [];
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    refs.push({
+      target: m[2].trim(),
+      heading: m[3] ?? '',
+      alias: m[4] ?? '',
+      embed: Boolean(m[1]),
+    });
+  }
+  return refs;
+}
+
+/**
+ * Rewrites wikilinks pointing to oldPath to point to newPath instead (vault-relative, no .md).
+ * Preserves heading anchors and aliases. Also rewrites embeds (![[target]]), used to reference
+ * binary files such as images, preserving the leading '!'.
+ *
+ * Matches both exact vault-relative path and bare basename (e.g., "recipe" from "food/recipe").
+ * Does not match partial names or headings-only links ([[#heading]]).
+ */
+export function rewriteLinks(content, oldPath, newPath) {
+  const oldBasename = path.posix.basename(oldPath);
+  const escapedPath = escRe(oldPath);
+  const escapedBase = escRe(oldBasename);
+
+  // Alternate on full path first (more specific), then basename
+  const targetPattern =
+    escapedPath === escapedBase
+      ? escapedPath
+      : `(?:${escapedPath}|${escapedBase})`;
+
+  // Pattern: !?[[target#heading|alias]] where the leading '!' (embed), #heading and
+  // |alias are all optional. The target must be followed by #, |, or ]] — not by other path chars
+  const re = new RegExp(
+    `(!)?\\[\\[(${targetPattern})(#[^\\]|]*)?(\\|[^\\]]*)?\\]\\]`,
+    'g',
+  );
+
+  return content.replace(re, (_match, embed, _target, heading, alias) => {
+    return `${embed ?? ''}[[${newPath}${heading ?? ''}${alias ?? ''}]]`;
+  });
+}