vault-mcp-tools 1.0.0

package/dist/index.js

@@ -0,0 +1,3005 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+
+// src/errors.ts
+var VaultError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "VaultError";
+  }
+  code;
+};
+function sanitizeErrorMessage(message, vaultRoot) {
+  const forwardSlash = vaultRoot.replace(/\\/g, "/");
+  const backSlash = vaultRoot.replace(/\//g, "\\");
+  let result = message;
+  result = result.replaceAll(forwardSlash, "<vault>");
+  result = result.replaceAll(backSlash, "<vault>");
+  result = result.replaceAll(vaultRoot, "<vault>");
+  return result;
+}
+function toolError(message, vaultRoot) {
+  const text = vaultRoot ? sanitizeErrorMessage(message, vaultRoot) : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+function toolResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function toolJson(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+
+// src/config.ts
+function loadConfig() {
+  const vaultPath = process.env.OBSIDIAN_VAULT_PATH;
+  if (!vaultPath) {
+    throw new VaultError(
+      "OBSIDIAN_VAULT_PATH environment variable is required",
+      "CONFIG_MISSING"
+    );
+  }
+  const resolved = path.resolve(vaultPath);
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) {
+      throw new VaultError(
+        `OBSIDIAN_VAULT_PATH is not a directory: ${resolved}`,
+        "CONFIG_INVALID"
+      );
+    }
+  } catch (err) {
+    if (err instanceof VaultError) throw err;
+    throw new VaultError(
+      `OBSIDIAN_VAULT_PATH does not exist: ${resolved}`,
+      "CONFIG_INVALID"
+    );
+  }
+  const restToken = process.env.OBSIDIAN_REST_TOKEN;
+  const restPort = parseInt(process.env.OBSIDIAN_REST_PORT ?? "27124", 10);
+  const transportEnv = process.env.OBSIDIAN_TRANSPORT ?? "stdio";
+  if (transportEnv !== "stdio" && transportEnv !== "http") {
+    throw new VaultError(
+      `Invalid OBSIDIAN_TRANSPORT: "${transportEnv}". Must be "stdio" or "http".`,
+      "CONFIG_INVALID"
+    );
+  }
+  const httpPort = parseInt(process.env.OBSIDIAN_HTTP_PORT ?? "3000", 10);
+  if (isNaN(httpPort) || httpPort < 1 || httpPort > 65535) {
+    throw new VaultError(
+      `Invalid OBSIDIAN_HTTP_PORT: "${process.env.OBSIDIAN_HTTP_PORT}". Must be 1-65535.`,
+      "CONFIG_INVALID"
+    );
+  }
+  const httpAuthToken = process.env.OBSIDIAN_HTTP_AUTH_TOKEN;
+  return {
+    vaultPath: resolved,
+    restToken,
+    restPort,
+    restAvailable: false,
+    // Set by probe in index.ts after config loads
+    transport: transportEnv,
+    httpPort,
+    httpAuthToken
+  };
+}
+
+// src/cache/metadata-cache.ts
+import path5 from "path";
+import chokidar from "chokidar";
+
+// src/fs/vault-io.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+
+// src/fs/vault-path.ts
+import path2 from "path";
+function normalizePath(inputPath) {
+  let result = inputPath.replace(/\\/g, "/");
+  result = result.replace(/^\/+/, "");
+  result = result.replace(/\/\/+/g, "/");
+  return result;
+}
+var SENSITIVE_DIRS = [".obsidian", ".git", ".trash", "node_modules"];
+function assertNotSensitiveDir(normalizedPath) {
+  for (const dir of SENSITIVE_DIRS) {
+    if (normalizedPath === dir || normalizedPath.startsWith(dir + "/")) {
+      throw new VaultError(
+        `Access denied: targets sensitive directory "${dir}"`,
+        "SENSITIVE_PATH"
+      );
+    }
+  }
+}
+function resolveVaultPath(vaultRoot, relativePath, options) {
+  if (relativePath.includes("\0")) {
+    throw new VaultError("Path contains null byte", "INVALID_PATH");
+  }
+  const normalized = normalizePath(relativePath);
+  if (!options?.allowSensitive) {
+    assertNotSensitiveDir(normalized);
+  }
+  const resolved = path2.resolve(vaultRoot, normalized);
+  const normalizedRoot = path2.resolve(vaultRoot);
+  if (!resolved.startsWith(normalizedRoot + path2.sep) && resolved !== normalizedRoot) {
+    throw new VaultError(
+      `Path traversal detected: ${relativePath}`,
+      "PATH_TRAVERSAL"
+    );
+  }
+  return resolved;
+}
+function toRelativePath(vaultRoot, absolutePath) {
+  const rel = path2.relative(vaultRoot, absolutePath);
+  return rel.replace(/\\/g, "/");
+}
+function isMarkdownFile(filePath) {
+  return path2.extname(filePath).toLowerCase() === ".md";
+}
+function getNoteName(filePath) {
+  return path2.basename(filePath, path2.extname(filePath));
+}
+
+// src/fs/write-lock.ts
+var WriteLock = class {
+  locks = /* @__PURE__ */ new Map();
+  async acquire(path9) {
+    const existing = this.locks.get(path9) ?? Promise.resolve();
+    let release;
+    const newPromise = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.locks.set(path9, existing.then(() => newPromise));
+    await existing;
+    return release;
+  }
+};
+
+// src/fs/vault-io.ts
+var writeLock = new WriteLock();
+var IGNORED_DIRS = /* @__PURE__ */ new Set([".obsidian", ".trash", ".git", "node_modules"]);
+async function rejectSymlink(absolutePath) {
+  try {
+    const lstats = await fs2.lstat(absolutePath);
+    if (lstats.isSymbolicLink()) {
+      throw new VaultError("Symlinks are not allowed", "SYMLINK_DENIED");
+    }
+  } catch (err) {
+    if (err instanceof VaultError) throw err;
+  }
+}
+async function readFile(vaultRoot, relativePath) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  await rejectSymlink(absolutePath);
+  try {
+    return await fs2.readFile(absolutePath, "utf-8");
+  } catch {
+    throw new VaultError(`File not found: ${relativePath}`, "NOT_FOUND");
+  }
+}
+async function writeFile(vaultRoot, relativePath, content) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  await rejectSymlink(absolutePath);
+  const release = await writeLock.acquire(relativePath);
+  try {
+    await fs2.mkdir(path3.dirname(absolutePath), { recursive: true });
+    const tmpPath = `${absolutePath}.tmp`;
+    await fs2.writeFile(tmpPath, content, "utf-8");
+    await fs2.rename(tmpPath, absolutePath);
+  } finally {
+    release();
+  }
+}
+async function deleteFile(vaultRoot, relativePath) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  await rejectSymlink(absolutePath);
+  const release = await writeLock.acquire(relativePath);
+  try {
+    await fs2.unlink(absolutePath);
+  } catch {
+    throw new VaultError(`File not found: ${relativePath}`, "NOT_FOUND");
+  } finally {
+    release();
+  }
+}
+async function fileExists(vaultRoot, relativePath) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  try {
+    await fs2.access(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listDirectory(vaultRoot, relativePath) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  let entries;
+  try {
+    entries = await fs2.readdir(absolutePath, { withFileTypes: true });
+  } catch {
+    throw new VaultError(`Directory not found: ${relativePath}`, "NOT_FOUND");
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (IGNORED_DIRS.has(entry.name)) continue;
+    const fullPath = path3.join(absolutePath, entry.name);
+    const stat = await fs2.lstat(fullPath);
+    if (stat.isSymbolicLink()) continue;
+    const entryRelPath = toRelativePath(vaultRoot, fullPath);
+    if (stat.isDirectory()) {
+      results.push({ name: entry.name, path: entryRelPath, type: "folder" });
+    } else if (stat.isFile()) {
+      results.push({
+        name: entry.name,
+        path: entryRelPath,
+        type: "file",
+        size: stat.size,
+        modified: stat.mtimeMs
+      });
+    }
+  }
+  return results;
+}
+async function createDirectory(vaultRoot, relativePath) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  await fs2.mkdir(absolutePath, { recursive: true });
+}
+async function getFileStats(vaultRoot, relativePath) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  await rejectSymlink(absolutePath);
+  const stat = await fs2.stat(absolutePath);
+  return { size: stat.size, modified: stat.mtimeMs };
+}
+async function walkDirectory(vaultRoot, relativePath) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  let stat;
+  try {
+    stat = await fs2.stat(absolutePath);
+  } catch {
+    throw new VaultError(`Directory not found: ${relativePath}`, "NOT_FOUND");
+  }
+  if (!stat.isDirectory()) {
+    throw new VaultError(`Not a directory: ${relativePath}`, "NOT_FOUND");
+  }
+  const results = [];
+  async function walk(dir) {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const fullPath = path3.join(dir, entry.name);
+      const stat2 = await fs2.lstat(fullPath);
+      if (stat2.isSymbolicLink()) continue;
+      if (stat2.isDirectory()) {
+        await walk(fullPath);
+      } else if (stat2.isFile()) {
+        results.push(toRelativePath(vaultRoot, fullPath));
+      }
+    }
+  }
+  await walk(absolutePath);
+  return results;
+}
+async function moveDirectory(vaultRoot, oldRelPath, newRelPath) {
+  const oldAbsPath = resolveVaultPath(vaultRoot, oldRelPath);
+  const newAbsPath = resolveVaultPath(vaultRoot, newRelPath);
+  let stat;
+  try {
+    stat = await fs2.stat(oldAbsPath);
+  } catch {
+    throw new VaultError(`Directory not found: ${oldRelPath}`, "NOT_FOUND");
+  }
+  if (!stat.isDirectory()) {
+    throw new VaultError(`Not a directory: ${oldRelPath}`, "NOT_FOUND");
+  }
+  try {
+    await fs2.stat(newAbsPath);
+    throw new VaultError(`Destination already exists: ${newRelPath}`, "CONFLICT");
+  } catch (err) {
+    if (err instanceof VaultError) throw err;
+  }
+  await fs2.mkdir(path3.dirname(newAbsPath), { recursive: true });
+  await fs2.rename(oldAbsPath, newAbsPath);
+}
+async function deleteEmptyDirectory(vaultRoot, relativePath) {
+  const absolutePath = resolveVaultPath(vaultRoot, relativePath);
+  const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!normalized || normalized === ".") {
+    throw new VaultError("Cannot delete vault root", "INVALID_OPERATION");
+  }
+  let stat;
+  try {
+    stat = await fs2.stat(absolutePath);
+  } catch {
+    throw new VaultError(`Directory not found: ${relativePath}`, "NOT_FOUND");
+  }
+  if (!stat.isDirectory()) {
+    throw new VaultError(`Not a directory: ${relativePath}`, "NOT_FOUND");
+  }
+  const entries = await fs2.readdir(absolutePath);
+  if (entries.length > 0) {
+    throw new VaultError(`Directory is not empty: ${relativePath}`, "NOT_EMPTY");
+  }
+  await fs2.rmdir(absolutePath);
+}
+async function* walkMarkdownFiles(vaultRoot) {
+  async function* walk(dir) {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const fullPath = path3.join(dir, entry.name);
+      const stat = await fs2.lstat(fullPath);
+      if (stat.isSymbolicLink()) continue;
+      if (stat.isDirectory()) {
+        yield* walk(fullPath);
+      } else if (stat.isFile() && isMarkdownFile(entry.name)) {
+        yield {
+          relativePath: toRelativePath(vaultRoot, fullPath),
+          absolutePath: fullPath
+        };
+      }
+    }
+  }
+  yield* walk(vaultRoot);
+}
+
+// src/parsers/frontmatter.ts
+import matter from "gray-matter";
+function parseFrontmatter(content) {
+  const result = matter(content);
+  return {
+    frontmatter: result.data ?? {},
+    body: result.content
+  };
+}
+function extractAliases(frontmatter) {
+  const raw = frontmatter.aliases ?? frontmatter.alias;
+  if (!raw) return [];
+  const items = [];
+  if (typeof raw === "string") {
+    items.push(raw);
+  } else if (Array.isArray(raw)) {
+    for (const item of raw) {
+      if (typeof item === "string") items.push(item);
+    }
+  }
+  return [...new Set(items)];
+}
+function extractFrontmatterTags(frontmatter) {
+  const raw = frontmatter.tags ?? frontmatter.tag;
+  if (!raw) return [];
+  let items = [];
+  if (typeof raw === "string") {
+    items = raw.split(",").map((t) => t.trim()).filter(Boolean);
+  } else if (Array.isArray(raw)) {
+    for (const item of raw) {
+      if (typeof item === "string") items.push(item);
+    }
+  }
+  return [...new Set(
+    items.map((tag) => {
+      const normalized = tag.toLowerCase();
+      return normalized.startsWith("#") ? normalized : `#${normalized}`;
+    })
+  )];
+}
+function setFrontmatterProperty(content, key, value) {
+  const parsed = matter(content);
+  parsed.data[key] = value;
+  return matter.stringify(parsed.content, parsed.data);
+}
+function removeFrontmatterProperty(content, key) {
+  const parsed = matter(content);
+  delete parsed.data[key];
+  return matter.stringify(parsed.content, parsed.data);
+}
+
+// src/parsers/wikilinks.ts
+var WIKILINK_REGEX = /(!?)\[\[([^\]]+?)\]\]/g;
+function parseWikilinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const cleaned = line.replace(/`[^`]*`/g, (match2) => " ".repeat(match2.length));
+    WIKILINK_REGEX.lastIndex = 0;
+    let match;
+    while ((match = WIKILINK_REGEX.exec(cleaned)) !== null) {
+      const isEmbed = match[1] === "!";
+      const inner = match[2];
+      const pipeIndex = inner.indexOf("|");
+      let target;
+      let alias;
+      if (pipeIndex !== -1) {
+        target = inner.slice(0, pipeIndex);
+        alias = inner.slice(pipeIndex + 1);
+      } else {
+        target = inner;
+        alias = null;
+      }
+      links.push({ target, alias, isEmbed, line: i });
+    }
+  }
+  return links;
+}
+
+// src/parsers/tags.ts
+var INLINE_TAG_REGEX = /(?:^|(?<=\s))#([\w-]+(?:\/[\w-]+)*)/g;
+function parseInlineTags(bodyContent) {
+  const tags = /* @__PURE__ */ new Set();
+  const lines = bodyContent.split("\n");
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const cleaned = line.replace(/`[^`]*`/g, (match2) => " ".repeat(match2.length));
+    INLINE_TAG_REGEX.lastIndex = 0;
+    let match;
+    while ((match = INLINE_TAG_REGEX.exec(cleaned)) !== null) {
+      const tagBody = match[1];
+      if (/^\d+$/.test(tagBody)) continue;
+      tags.add(`#${tagBody.toLowerCase()}`);
+    }
+  }
+  return [...tags];
+}
+function mergeTags(frontmatterTags, inlineTags) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const tag of [...frontmatterTags, ...inlineTags]) {
+    const normalized = tag.toLowerCase();
+    const withHash = normalized.startsWith("#") ? normalized : `#${normalized}`;
+    if (!seen.has(withHash)) {
+      seen.add(withHash);
+      result.push(withHash);
+    }
+  }
+  return result;
+}
+
+// src/parsers/headings.ts
+var HEADING_REGEX = /^(#{1,6})\s+(.+?)(?:\s+#+)?$/;
+function parseHeadings(bodyContent) {
+  const headings = [];
+  const lines = bodyContent.split("\n");
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const match = HEADING_REGEX.exec(line);
+    if (match) {
+      headings.push({
+        level: match[1].length,
+        text: match[2],
+        line: i
+      });
+    }
+  }
+  return headings;
+}
+
+// src/parsers/blocks.ts
+var BLOCK_REF_REGEX = /\^([a-zA-Z0-9][\w-]*)$/;
+function parseBlockRefs(bodyContent) {
+  const blocks = [];
+  const lines = bodyContent.split("\n");
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const match = BLOCK_REF_REGEX.exec(line.trimEnd());
+    if (match) {
+      blocks.push({ id: match[1], line: i });
+    }
+  }
+  return blocks;
+}
+
+// src/parsers/note-parser.ts
+import path4 from "path";
+function parseNote(relativePath, content, stats) {
+  const { frontmatter, body } = parseFrontmatter(content);
+  const aliases = extractAliases(frontmatter);
+  const frontmatterTags = extractFrontmatterTags(frontmatter);
+  const inlineTags = parseInlineTags(body);
+  const tags = mergeTags(frontmatterTags, inlineTags);
+  const headings = parseHeadings(body);
+  const blocks = parseBlockRefs(body);
+  const outgoingLinks = parseWikilinks(body);
+  return {
+    path: relativePath,
+    name: getNoteName(relativePath),
+    extension: path4.extname(relativePath).slice(1),
+    frontmatter,
+    aliases,
+    tags,
+    headings,
+    blocks,
+    outgoingLinks,
+    created: stats.modified,
+    modified: stats.modified,
+    size: stats.size
+  };
+}
+
+// src/cache/metadata-cache.ts
+var MetadataCache = class {
+  constructor(vaultRoot) {
+    this.vaultRoot = vaultRoot;
+  }
+  vaultRoot;
+  notes = /* @__PURE__ */ new Map();
+  nameIndex = /* @__PURE__ */ new Map();
+  aliasIndex = /* @__PURE__ */ new Map();
+  tagIndex = /* @__PURE__ */ new Map();
+  watcher = null;
+  mutedPaths = /* @__PURE__ */ new Set();
+  muteTimers = /* @__PURE__ */ new Map();
+  async initialize() {
+    for await (const { relativePath } of walkMarkdownFiles(this.vaultRoot)) {
+      await this._updateNote(relativePath);
+    }
+  }
+  startWatching() {
+    this.watcher = chokidar.watch(this.vaultRoot, {
+      ignored: /(^|[/\\])(\.(obsidian|trash|git)|node_modules)[/\\]/,
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+      usePolling: false
+    });
+    this.watcher.on("add", (absPath) => this._handleFileEvent(absPath));
+    this.watcher.on("change", (absPath) => this._handleFileEvent(absPath));
+    this.watcher.on("unlink", (absPath) => this._handleUnlink(absPath));
+  }
+  /**
+   * Temporarily suppress watcher events for a path.
+   * Used by write operations to prevent redundant re-parse of files we just wrote.
+   * Auto-expires after 5 seconds as safety net.
+   */
+  mutePath(relativePath) {
+    this.mutedPaths.add(relativePath);
+    const existing = this.muteTimers.get(relativePath);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.mutedPaths.delete(relativePath);
+      this.muteTimers.delete(relativePath);
+    }, 5e3);
+    this.muteTimers.set(relativePath, timer);
+  }
+  /**
+   * Clear all mute timers. Called during shutdown.
+   */
+  clearMutes() {
+    for (const timer of this.muteTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.mutedPaths.clear();
+    this.muteTimers.clear();
+  }
+  async stopWatching() {
+    this.clearMutes();
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  getNote(notePath) {
+    return this.notes.get(notePath);
+  }
+  getNoteByName(name) {
+    const paths = this.nameIndex.get(name.toLowerCase());
+    if (!paths || paths.length === 0) return void 0;
+    const sorted = [...paths].sort((a, b) => a.length - b.length || a.localeCompare(b));
+    return this.notes.get(sorted[0]);
+  }
+  resolveLink(target) {
+    let base = target.replace(/^\[\[/, "").replace(/\]\]$/, "");
+    const hashIndex = base.indexOf("#");
+    if (hashIndex !== -1) base = base.slice(0, hashIndex);
+    const caretIndex = base.indexOf("^");
+    if (caretIndex !== -1) base = base.slice(0, caretIndex);
+    base = base.trim();
+    if (!base) return null;
+    const lowerBase = base.toLowerCase();
+    if (base.includes("/")) {
+      const withMd = base.endsWith(".md") ? base : `${base}.md`;
+      const meta = this.notes.get(withMd);
+      if (meta) {
+        return {
+          path: meta.path,
+          name: meta.name,
+          isAmbiguous: false,
+          allMatches: [meta.path]
+        };
+      }
+    }
+    const nameKey = lowerBase.endsWith(".md") ? lowerBase.slice(0, -3) : lowerBase;
+    const nameMatches = this.nameIndex.get(nameKey);
+    if (nameMatches && nameMatches.length > 0) {
+      const sorted = [...nameMatches].sort((a, b) => a.length - b.length || a.localeCompare(b));
+      const best = this.notes.get(sorted[0]);
+      return {
+        path: best.path,
+        name: best.name,
+        isAmbiguous: sorted.length > 1,
+        allMatches: sorted
+      };
+    }
+    const aliasMatches = this.aliasIndex.get(lowerBase);
+    if (aliasMatches && aliasMatches.length > 0) {
+      const sorted = [...aliasMatches].sort((a, b) => a.length - b.length || a.localeCompare(b));
+      const best = this.notes.get(sorted[0]);
+      return {
+        path: best.path,
+        name: best.name,
+        isAmbiguous: sorted.length > 1,
+        allMatches: sorted
+      };
+    }
+    return null;
+  }
+  async searchContent(query, maxResults = 50) {
+    const lowerQuery = query.toLowerCase();
+    const results = [];
+    const MAX_MATCHES_PER_FILE = 5;
+    const MAX_LINE_LENGTH = 300;
+    for (const [notePath, metadata] of this.notes) {
+      if (results.length >= maxResults * 2) break;
+      try {
+        const content = await readFile(this.vaultRoot, notePath);
+        const lines = content.split("\n");
+        const matches = [];
+        for (let i = 0; i < lines.length; i++) {
+          if (matches.length >= MAX_MATCHES_PER_FILE) break;
+          const lowerLine = lines[i].toLowerCase();
+          const col = lowerLine.indexOf(lowerQuery);
+          if (col !== -1) {
+            const text = lines[i].length > MAX_LINE_LENGTH ? lines[i].slice(0, MAX_LINE_LENGTH) + "..." : lines[i];
+            matches.push({ line: i, text, column: col });
+          }
+        }
+        if (matches.length > 0) {
+          results.push({
+            path: notePath,
+            name: metadata.name,
+            matches,
+            score: matches.length
+          });
+        }
+      } catch {
+      }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, maxResults);
+  }
+  getNotesWithTag(tag) {
+    const normalized = tag.toLowerCase();
+    const withHash = normalized.startsWith("#") ? normalized : `#${normalized}`;
+    const paths = this.tagIndex.get(withHash);
+    if (!paths) return [];
+    return [...paths].map((p) => this.notes.get(p)).filter((n) => n !== void 0);
+  }
+  getNotesWithFrontmatter(key, value) {
+    const results = [];
+    for (const meta of this.notes.values()) {
+      if (!(key in meta.frontmatter)) continue;
+      if (value === void 0) {
+        results.push(meta);
+      } else {
+        const fmValue = meta.frontmatter[key];
+        if (fmValue === value) {
+          results.push(meta);
+        } else if (Array.isArray(fmValue) && fmValue.includes(value)) {
+          results.push(meta);
+        }
+      }
+    }
+    return results;
+  }
+  getAllTags() {
+    const tags = [];
+    for (const [tag, paths] of this.tagIndex) {
+      tags.push({ tag, count: paths.size });
+    }
+    return tags.sort((a, b) => a.tag.localeCompare(b.tag));
+  }
+  getStats() {
+    let totalSize = 0;
+    let folderSet = /* @__PURE__ */ new Set();
+    let oldest = null;
+    let newest = null;
+    let largest = null;
+    for (const meta of this.notes.values()) {
+      totalSize += meta.size;
+      const dir = path5.dirname(meta.path);
+      if (dir !== ".") folderSet.add(dir);
+      if (!oldest || meta.modified < oldest.modified) {
+        oldest = { path: meta.path, modified: meta.modified };
+      }
+      if (!newest || meta.modified > newest.modified) {
+        newest = { path: meta.path, modified: meta.modified };
+      }
+      if (!largest || meta.size > largest.size) {
+        largest = { path: meta.path, size: meta.size };
+      }
+    }
+    return {
+      noteCount: this.notes.size,
+      folderCount: folderSet.size,
+      tagCount: this.tagIndex.size,
+      totalSize,
+      averageNoteSize: this.notes.size > 0 ? Math.round(totalSize / this.notes.size) : 0,
+      oldestNote: oldest,
+      newestNote: newest,
+      largestNote: largest
+    };
+  }
+  getVaultInfo() {
+    const stats = this.getStats();
+    return {
+      name: path5.basename(this.vaultRoot),
+      noteCount: stats.noteCount,
+      folderCount: stats.folderCount,
+      totalSize: stats.totalSize
+    };
+  }
+  getRecentNotes(limit) {
+    return [...this.notes.values()].sort((a, b) => b.modified - a.modified).slice(0, limit);
+  }
+  /**
+   * Reindex after a batch operation. Removes old paths and re-parses new paths.
+   * Used by folder move and other bulk operations.
+   */
+  async reindexPaths(removed, added) {
+    for (const relPath of removed) {
+      this._removeNote(relPath);
+    }
+    for (const relPath of added) {
+      await this._updateNote(relPath);
+    }
+  }
+  // --- Private methods ---
+  _addToIndex(metadata) {
+    const lowerName = metadata.name.toLowerCase();
+    const namePaths = this.nameIndex.get(lowerName) ?? [];
+    if (!namePaths.includes(metadata.path)) {
+      namePaths.push(metadata.path);
+    }
+    this.nameIndex.set(lowerName, namePaths);
+    for (const alias of metadata.aliases) {
+      const lowerAlias = alias.toLowerCase();
+      const aliasPaths = this.aliasIndex.get(lowerAlias) ?? [];
+      if (!aliasPaths.includes(metadata.path)) {
+        aliasPaths.push(metadata.path);
+      }
+      this.aliasIndex.set(lowerAlias, aliasPaths);
+    }
+    for (const tag of metadata.tags) {
+      const tagPaths = this.tagIndex.get(tag) ?? /* @__PURE__ */ new Set();
+      tagPaths.add(metadata.path);
+      this.tagIndex.set(tag, tagPaths);
+    }
+  }
+  _removeFromIndex(metadata) {
+    const lowerName = metadata.name.toLowerCase();
+    const namePaths = this.nameIndex.get(lowerName);
+    if (namePaths) {
+      const filtered = namePaths.filter((p) => p !== metadata.path);
+      if (filtered.length === 0) {
+        this.nameIndex.delete(lowerName);
+      } else {
+        this.nameIndex.set(lowerName, filtered);
+      }
+    }
+    for (const alias of metadata.aliases) {
+      const lowerAlias = alias.toLowerCase();
+      const aliasPaths = this.aliasIndex.get(lowerAlias);
+      if (aliasPaths) {
+        const filtered = aliasPaths.filter((p) => p !== metadata.path);
+        if (filtered.length === 0) {
+          this.aliasIndex.delete(lowerAlias);
+        } else {
+          this.aliasIndex.set(lowerAlias, filtered);
+        }
+      }
+    }
+    for (const tag of metadata.tags) {
+      const tagPaths = this.tagIndex.get(tag);
+      if (tagPaths) {
+        tagPaths.delete(metadata.path);
+        if (tagPaths.size === 0) {
+          this.tagIndex.delete(tag);
+        }
+      }
+    }
+  }
+  async _updateNote(relativePath) {
+    const existing = this.notes.get(relativePath);
+    if (existing) this._removeFromIndex(existing);
+    try {
+      const content = await readFile(this.vaultRoot, relativePath);
+      const stats = await getFileStats(this.vaultRoot, relativePath);
+      const metadata = parseNote(relativePath, content, stats);
+      this.notes.set(relativePath, metadata);
+      this._addToIndex(metadata);
+    } catch {
+      this.notes.delete(relativePath);
+    }
+  }
+  _removeNote(relativePath) {
+    const existing = this.notes.get(relativePath);
+    if (existing) {
+      this._removeFromIndex(existing);
+      this.notes.delete(relativePath);
+    }
+  }
+  _handleFileEvent(absPath) {
+    const relPath = toRelativePath(this.vaultRoot, absPath);
+    if (!isMarkdownFile(relPath)) return;
+    if (this.mutedPaths.has(relPath)) {
+      this.mutedPaths.delete(relPath);
+      const timer = this.muteTimers.get(relPath);
+      if (timer) clearTimeout(timer);
+      this.muteTimers.delete(relPath);
+      return;
+    }
+    this._updateNote(relPath).catch((err) => {
+      console.error(`[vault-mcp] Error updating cache for ${relPath}:`, err);
+    });
+  }
+  _handleUnlink(absPath) {
+    const relPath = toRelativePath(this.vaultRoot, absPath);
+    if (!isMarkdownFile(relPath)) return;
+    if (this.mutedPaths.has(relPath)) {
+      this.mutedPaths.delete(relPath);
+      const timer = this.muteTimers.get(relPath);
+      if (timer) clearTimeout(timer);
+      this.muteTimers.delete(relPath);
+      return;
+    }
+    this._removeNote(relPath);
+  }
+};
+
+// src/tools/register-tools.ts
+import { z } from "zod";
+
+// src/graph/link-updater.ts
+async function updateLinksAfterMove(vaultRoot, cache, oldPath, newPath) {
+  const oldName = getNoteName(oldPath);
+  const newName = getNoteName(newPath);
+  const oldPathNoExt = oldPath.replace(/\.md$/, "");
+  const newPathNoExt = newPath.replace(/\.md$/, "");
+  const newNameLower = newName.toLowerCase();
+  const nameMatches = cache.nameIndex.get(newNameLower) ?? [];
+  const otherMatchCount = nameMatches.filter((p) => p !== oldPath && p !== newPath).length;
+  const isAmbiguous = otherMatchCount > 0;
+  const newRef = isAmbiguous ? newPathNoExt : newName;
+  const notesToUpdate = [];
+  for (const [notePath, note] of cache.notes) {
+    if (notePath === oldPath || notePath === newPath) continue;
+    for (const link of note.outgoingLinks) {
+      const resolved = cache.resolveLink(link.target);
+      if (resolved && resolved.path === oldPath) {
+        notesToUpdate.push(notePath);
+        break;
+      }
+    }
+  }
+  const updatedFiles = [];
+  let updatedCount = 0;
+  for (const notePath of notesToUpdate) {
+    const content = await readFile(vaultRoot, notePath);
+    const { result, count } = replaceLinksInContent(content, oldName, oldPathNoExt, newRef);
+    if (count > 0) {
+      cache.mutePath(notePath);
+      await writeFile(vaultRoot, notePath, result);
+      updatedFiles.push(notePath);
+      updatedCount += count;
+    }
+  }
+  return { updatedFiles, updatedCount };
+}
+async function updateLinksAfterBatchMove(vaultRoot, cache, moves) {
+  if (moves.size === 0) return { updatedFiles: [], updatedCount: 0 };
+  const moveInfo = /* @__PURE__ */ new Map();
+  for (const [oldPath, newPath] of moves) {
+    const oldName = getNoteName(oldPath);
+    const oldPathNoExt = oldPath.replace(/\.md$/, "");
+    const newName = getNoteName(newPath);
+    const newPathNoExt = newPath.replace(/\.md$/, "");
+    const newNameLower = newName.toLowerCase();
+    const nameMatches = cache.nameIndex.get(newNameLower) ?? [];
+    const otherMatchCount = nameMatches.filter(
+      (p) => !moves.has(p) && ![...moves.values()].includes(p)
+    ).length;
+    const isAmbiguous = otherMatchCount > 0;
+    const newRef = isAmbiguous ? newPathNoExt : newName;
+    moveInfo.set(oldPath, { oldName, oldPathNoExt, newRef });
+  }
+  const notesToUpdate = [];
+  const movedPaths = /* @__PURE__ */ new Set([...moves.keys(), ...moves.values()]);
+  for (const [notePath, note] of cache.notes) {
+    if (movedPaths.has(notePath)) continue;
+    let needsUpdate = false;
+    for (const link of note.outgoingLinks) {
+      const resolved = cache.resolveLink(link.target);
+      if (resolved && moves.has(resolved.path)) {
+        needsUpdate = true;
+        break;
+      }
+    }
+    if (needsUpdate) notesToUpdate.push(notePath);
+  }
+  const updatedFiles = [];
+  let updatedCount = 0;
+  for (const notePath of notesToUpdate) {
+    let content = await readFile(vaultRoot, notePath);
+    let fileCount = 0;
+    for (const [_oldPath, info] of moveInfo) {
+      const { result, count } = replaceLinksInContent(
+        content,
+        info.oldName,
+        info.oldPathNoExt,
+        info.newRef
+      );
+      content = result;
+      fileCount += count;
+    }
+    if (fileCount > 0) {
+      cache.mutePath(notePath);
+      await writeFile(vaultRoot, notePath, content);
+      updatedFiles.push(notePath);
+      updatedCount += fileCount;
+    }
+  }
+  return { updatedFiles, updatedCount };
+}
+function replaceLinksInContent(content, oldName, oldPathNoExt, newRef) {
+  const lines = content.split("\n");
+  let inCodeBlock = false;
+  let count = 0;
+  const escapedName = escapeRegex(oldName);
+  const escapedPath = escapeRegex(oldPathNoExt);
+  const pattern = new RegExp(
+    `(!?)\\[\\[(${escapedPath}|${escapedName})(\\|[^\\]]*)?\\]\\]`,
+    "g"
+  );
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const inlineCodeSpans = [];
+    const inlineCodeRegex = /`[^`]*`/g;
+    let codeMatch;
+    while ((codeMatch = inlineCodeRegex.exec(line)) !== null) {
+      inlineCodeSpans.push({
+        start: codeMatch.index,
+        end: codeMatch.index + codeMatch[0].length,
+        text: codeMatch[0]
+      });
+    }
+    pattern.lastIndex = 0;
+    let newLine = "";
+    let lastIndex = 0;
+    let linkMatch;
+    while ((linkMatch = pattern.exec(line)) !== null) {
+      const matchStart = linkMatch.index;
+      const matchEnd = matchStart + linkMatch[0].length;
+      const insideCode = inlineCodeSpans.some(
+        (span) => matchStart >= span.start && matchEnd <= span.end
+      );
+      if (insideCode) continue;
+      newLine += line.slice(lastIndex, matchStart);
+      const embedPrefix = linkMatch[1];
+      const alias = linkMatch[3];
+      if (alias) {
+        newLine += `${embedPrefix}[[${newRef}${alias}]]`;
+      } else {
+        newLine += `${embedPrefix}[[${newRef}]]`;
+      }
+      count++;
+      lastIndex = matchEnd;
+    }
+    if (lastIndex > 0) {
+      newLine += line.slice(lastIndex);
+      lines[i] = newLine;
+    }
+  }
+  return { result: lines.join("\n"), count };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/tools/note-tools.ts
+import matter2 from "gray-matter";
+async function readNote(cache, config, args) {
+  try {
+    const content = await readFile(config.vaultPath, args.path);
+    const { frontmatter, body } = parseFrontmatter(content);
+    const meta = cache.getNote(args.path);
+    return toolJson({
+      path: args.path,
+      name: meta?.name ?? args.path,
+      frontmatter,
+      content: body,
+      tags: meta?.tags ?? [],
+      headings: meta?.headings ?? []
+    });
+  } catch (err) {
+    return toolError(`Failed to read note: ${err.message}`, config.vaultPath);
+  }
+}
+async function createNote(cache, config, args) {
+  try {
+    if (await fileExists(config.vaultPath, args.path)) {
+      return toolError(`Note already exists: ${args.path}`, config.vaultPath);
+    }
+    let fileContent = args.content;
+    if (args.frontmatter && Object.keys(args.frontmatter).length > 0) {
+      fileContent = matter2.stringify(args.content, args.frontmatter);
+    }
+    cache.mutePath(args.path);
+    await writeFile(config.vaultPath, args.path, fileContent);
+    return toolResult(`Created note: ${args.path}`);
+  } catch (err) {
+    return toolError(`Failed to create note: ${err.message}`, config.vaultPath);
+  }
+}
+async function updateNote(cache, config, args) {
+  try {
+    if (!await fileExists(config.vaultPath, args.path)) {
+      return toolError(`Note does not exist: ${args.path}`, config.vaultPath);
+    }
+    let fileContent;
+    if (args.frontmatter) {
+      fileContent = matter2.stringify(args.content, args.frontmatter);
+    } else {
+      const existing = await readFile(config.vaultPath, args.path);
+      const { frontmatter } = parseFrontmatter(existing);
+      if (Object.keys(frontmatter).length > 0) {
+        fileContent = matter2.stringify(args.content, frontmatter);
+      } else {
+        fileContent = args.content;
+      }
+    }
+    cache.mutePath(args.path);
+    await writeFile(config.vaultPath, args.path, fileContent);
+    return toolResult(`Updated note: ${args.path}`);
+  } catch (err) {
+    return toolError(`Failed to update note: ${err.message}`, config.vaultPath);
+  }
+}
+async function patchNote(cache, config, args) {
+  try {
+    if (args.targetType && !args.target) {
+      return toolError("target is required when targetType is set", config.vaultPath);
+    }
+    const existing = await readFile(config.vaultPath, args.path);
+    const { frontmatter, body } = parseFrontmatter(existing);
+    let newContent;
+    if (!args.targetType) {
+      switch (args.operation) {
+        case "append":
+          newContent = existing.trimEnd() + "\n\n" + args.content;
+          break;
+        case "prepend":
+          if (Object.keys(frontmatter).length > 0) {
+            newContent = matter2.stringify("\n" + args.content + "\n\n" + body, frontmatter);
+          } else {
+            newContent = args.content + "\n\n" + existing;
+          }
+          break;
+        case "replace":
+          if (Object.keys(frontmatter).length > 0) {
+            newContent = matter2.stringify("\n" + args.content, frontmatter);
+          } else {
+            newContent = args.content;
+          }
+          break;
+      }
+    } else if (args.targetType === "heading") {
+      const headings = parseHeadings(body);
+      const target = headings.find(
+        (h) => h.text.toLowerCase() === args.target.toLowerCase()
+      );
+      if (!target) {
+        return toolError(`Heading not found: ${args.target}`, config.vaultPath);
+      }
+      const bodyLines = body.split("\n");
+      const startLine = target.line;
+      let endLine = bodyLines.length;
+      for (let i = startLine + 1; i < bodyLines.length; i++) {
+        const nextHeading = headings.find((h) => h.line === i);
+        if (nextHeading && nextHeading.level <= target.level) {
+          endLine = i;
+          break;
+        }
+      }
+      const sectionContent = bodyLines.slice(startLine + 1, endLine).join("\n");
+      let newSection;
+      switch (args.operation) {
+        case "append":
+          newSection = sectionContent.trimEnd() + "\n\n" + args.content;
+          break;
+        case "prepend":
+          newSection = "\n" + args.content + "\n" + sectionContent;
+          break;
+        case "replace":
+          newSection = "\n" + args.content;
+          break;
+      }
+      const newBodyLines = [
+        ...bodyLines.slice(0, startLine + 1),
+        ...newSection.split("\n"),
+        ...bodyLines.slice(endLine)
+      ];
+      const newBody = newBodyLines.join("\n");
+      if (Object.keys(frontmatter).length > 0) {
+        newContent = matter2.stringify("\n" + newBody, frontmatter);
+      } else {
+        newContent = newBody;
+      }
+    } else if (args.targetType === "block") {
+      const blocks = parseBlockRefs(body);
+      const target = blocks.find((b) => b.id === args.target);
+      if (!target) {
+        return toolError(`Block not found: ^${args.target}`, config.vaultPath);
+      }
+      const bodyLines = body.split("\n");
+      const blockLine = target.line;
+      switch (args.operation) {
+        case "append":
+          bodyLines.splice(blockLine + 1, 0, args.content);
+          break;
+        case "prepend":
+          bodyLines.splice(blockLine, 0, args.content);
+          break;
+        case "replace":
+          bodyLines[blockLine] = args.content;
+          break;
+      }
+      const newBody = bodyLines.join("\n");
+      if (Object.keys(frontmatter).length > 0) {
+        newContent = matter2.stringify("\n" + newBody, frontmatter);
+      } else {
+        newContent = newBody;
+      }
+    } else if (args.targetType === "frontmatter") {
+      if (args.operation === "replace") {
+        newContent = setFrontmatterProperty(existing, args.target, args.content);
+      } else {
+        return toolError("Only 'replace' operation is supported for frontmatter targets", config.vaultPath);
+      }
+    } else {
+      return toolError(`Unknown targetType: ${args.targetType}`, config.vaultPath);
+    }
+    cache.mutePath(args.path);
+    await writeFile(config.vaultPath, args.path, newContent);
+    return toolResult(`Patched note: ${args.path} (${args.operation}${args.targetType ? ` on ${args.targetType}:${args.target}` : ""})`);
+  } catch (err) {
+    return toolError(`Failed to patch note: ${err.message}`, config.vaultPath);
+  }
+}
+async function deleteNote(cache, config, args) {
+  try {
+    if (!await fileExists(config.vaultPath, args.path)) {
+      return toolError(`Note does not exist: ${args.path}`, config.vaultPath);
+    }
+    cache.mutePath(args.path);
+    await deleteFile(config.vaultPath, args.path);
+    return toolResult(`Deleted note: ${args.path}`);
+  } catch (err) {
+    return toolError(`Failed to delete note: ${err.message}`, config.vaultPath);
+  }
+}
+async function moveNote(cache, config, args) {
+  try {
+    if (!await fileExists(config.vaultPath, args.path)) {
+      return toolError(`Note does not exist: ${args.path}`, config.vaultPath);
+    }
+    if (await fileExists(config.vaultPath, args.newPath)) {
+      return toolError(`Destination already exists: ${args.newPath}`, config.vaultPath);
+    }
+    const content = await readFile(config.vaultPath, args.path);
+    const linkResult = await updateLinksAfterMove(
+      config.vaultPath,
+      cache,
+      args.path,
+      args.newPath
+    );
+    cache.mutePath(args.path);
+    cache.mutePath(args.newPath);
+    await writeFile(config.vaultPath, args.newPath, content);
+    await deleteFile(config.vaultPath, args.path);
+    return toolJson({
+      moved: { from: args.path, to: args.newPath },
+      linksUpdated: linkResult.updatedCount,
+      filesUpdated: linkResult.updatedFiles
+    });
+  } catch (err) {
+    return toolError(`Failed to move note: ${err.message}`, config.vaultPath);
+  }
+}
+async function renameNote(cache, config, args) {
+  try {
+    if (!await fileExists(config.vaultPath, args.path)) {
+      return toolError(`Note does not exist: ${args.path}`, config.vaultPath);
+    }
+    const parts = args.path.split("/");
+    const newFileName = args.newName.endsWith(".md") ? args.newName : `${args.newName}.md`;
+    parts[parts.length - 1] = newFileName;
+    const newPath = parts.join("/");
+    if (await fileExists(config.vaultPath, newPath)) {
+      return toolError(`Note already exists: ${newPath}`, config.vaultPath);
+    }
+    const content = await readFile(config.vaultPath, args.path);
+    const linkResult = await updateLinksAfterMove(
+      config.vaultPath,
+      cache,
+      args.path,
+      newPath
+    );
+    cache.mutePath(args.path);
+    cache.mutePath(newPath);
+    await writeFile(config.vaultPath, newPath, content);
+    await deleteFile(config.vaultPath, args.path);
+    return toolJson({
+      renamed: { from: args.path, to: newPath },
+      linksUpdated: linkResult.updatedCount,
+      filesUpdated: linkResult.updatedFiles
+    });
+  } catch (err) {
+    return toolError(`Failed to rename note: ${err.message}`, config.vaultPath);
+  }
+}
+
+// src/tools/search-tools.ts
+async function search(cache, config, args) {
+  try {
+    const limit = args.limit ?? 20;
+    const results = await cache.searchContent(args.query, limit);
+    return toolJson(results);
+  } catch (err) {
+    return toolError(`Search failed: ${err.message}`, config.vaultPath);
+  }
+}
+async function searchByTag(cache, config, args) {
+  try {
+    const notes = cache.getNotesWithTag(args.tag);
+    return toolJson(notes.map((n) => ({ path: n.path, name: n.name, tags: n.tags })));
+  } catch (err) {
+    return toolError(`Tag search failed: ${err.message}`, config.vaultPath);
+  }
+}
+async function searchStructured(cache, config, args) {
+  try {
+    let candidates = [...cache.notes.values()];
+    if (args.folder) {
+      let folder = normalizePath(args.folder);
+      if (!folder.endsWith("/")) folder += "/";
+      candidates = candidates.filter((n) => n.path.startsWith(folder));
+    }
+    if (args.tags && args.tags.length > 0) {
+      const normalizedTags = args.tags.map((t) => {
+        const lower = t.toLowerCase();
+        return lower.startsWith("#") ? lower : `#${lower}`;
+      });
+      candidates = candidates.filter(
+        (n) => normalizedTags.every((tag) => n.tags.includes(tag))
+      );
+    }
+    if (args.frontmatter && args.frontmatter.length > 0) {
+      candidates = candidates.filter(
+        (n) => args.frontmatter.every(({ key, value }) => {
+          if (!(key in n.frontmatter)) return false;
+          if (value === void 0) return true;
+          const fmValue = n.frontmatter[key];
+          if (fmValue === value) return true;
+          if (Array.isArray(fmValue) && fmValue.includes(value)) return true;
+          return false;
+        })
+      );
+    }
+    let results;
+    if (args.query && args.query.trim()) {
+      const lowerQuery = args.query.toLowerCase();
+      const matched = [];
+      const MAX_LINE_LENGTH = 300;
+      for (const note of candidates) {
+        try {
+          const content = await readFile(config.vaultPath, note.path);
+          const lines = content.split("\n");
+          const matches = [];
+          for (let i = 0; i < lines.length; i++) {
+            const lowerLine = lines[i].toLowerCase();
+            const col = lowerLine.indexOf(lowerQuery);
+            if (col !== -1) {
+              const text = lines[i].length > MAX_LINE_LENGTH ? lines[i].slice(0, MAX_LINE_LENGTH) + "..." : lines[i];
+              matches.push({ line: i, text, column: col });
+              if (matches.length >= 5) break;
+            }
+          }
+          if (matches.length > 0) {
+            matched.push({
+              path: note.path,
+              name: note.name,
+              tags: note.tags,
+              modified: note.modified,
+              size: note.size,
+              matches
+            });
+          }
+        } catch {
+        }
+      }
+      results = matched;
+    } else {
+      results = candidates.map((n) => ({
+        path: n.path,
+        name: n.name,
+        tags: n.tags,
+        modified: n.modified,
+        size: n.size
+      }));
+    }
+    const sortField = args.sort ?? "modified";
+    const defaultOrder = sortField === "name" ? "asc" : "desc";
+    const order = args.sortOrder ?? defaultOrder;
+    const dir = order === "asc" ? 1 : -1;
+    results.sort((a, b) => {
+      switch (sortField) {
+        case "modified":
+          return (a.modified - b.modified) * dir;
+        case "created":
+          return (a.modified - b.modified) * dir;
+        case "name":
+          return a.name.localeCompare(b.name) * dir;
+        case "size":
+          return (a.size - b.size) * dir;
+        default:
+          return 0;
+      }
+    });
+    const limit = Math.min(args.limit ?? 20, 100);
+    return toolJson(results.slice(0, limit));
+  } catch (err) {
+    return toolError(`Structured search failed: ${err.message}`, config.vaultPath);
+  }
+}
+async function searchByFrontmatter(cache, config, args) {
+  try {
+    const notes = cache.getNotesWithFrontmatter(args.key, args.value);
+    return toolJson(notes.map((n) => ({ path: n.path, name: n.name, frontmatter: n.frontmatter })));
+  } catch (err) {
+    return toolError(`Frontmatter search failed: ${err.message}`, config.vaultPath);
+  }
+}
+
+// src/tools/frontmatter-tools.ts
+async function getProperties(_cache, config, args) {
+  try {
+    const content = await readFile(config.vaultPath, args.path);
+    const { frontmatter } = parseFrontmatter(content);
+    return toolJson(frontmatter);
+  } catch (err) {
+    return toolError(`Failed to get properties: ${err.message}`, config.vaultPath);
+  }
+}
+async function setProperty(_cache, config, args) {
+  try {
+    const content = await readFile(config.vaultPath, args.path);
+    const updated = setFrontmatterProperty(content, args.key, args.value);
+    await writeFile(config.vaultPath, args.path, updated);
+    return toolResult(`Set property '${args.key}' on ${args.path}`);
+  } catch (err) {
+    return toolError(`Failed to set property: ${err.message}`, config.vaultPath);
+  }
+}
+async function removeProperty(_cache, config, args) {
+  try {
+    const content = await readFile(config.vaultPath, args.path);
+    const updated = removeFrontmatterProperty(content, args.key);
+    await writeFile(config.vaultPath, args.path, updated);
+    return toolResult(`Removed property '${args.key}' from ${args.path}`);
+  } catch (err) {
+    return toolError(`Failed to remove property: ${err.message}`, config.vaultPath);
+  }
+}
+
+// src/tools/tag-tools.ts
+async function listTags(cache, config, _args) {
+  try {
+    return toolJson(cache.getAllTags());
+  } catch (err) {
+    return toolError(`Failed to list tags: ${err.message}`, config.vaultPath);
+  }
+}
+async function getNoteTags(cache, config, args) {
+  try {
+    const meta = cache.getNote(args.path);
+    if (!meta) {
+      return toolError(`Note not found: ${args.path}`, config.vaultPath);
+    }
+    return toolJson({ path: meta.path, tags: meta.tags });
+  } catch (err) {
+    return toolError(`Failed to get note tags: ${err.message}`, config.vaultPath);
+  }
+}
+async function renameTag(cache, config, args) {
+  const oldNorm = normalizeTag(args.oldTag);
+  const newNorm = normalizeTag(args.newTag);
+  if (oldNorm === newNorm) {
+    return toolError("Old and new tag are identical", config.vaultPath);
+  }
+  const oldBare = oldNorm.slice(1);
+  const newBare = newNorm.slice(1);
+  const notesWithTag = cache.getNotesWithTag(oldNorm);
+  if (notesWithTag.length === 0) {
+    return toolJson({ filesAffected: 0, dryRun: args.dryRun ?? false, oldTag: oldNorm, newTag: newNorm });
+  }
+  let filesAffected = 0;
+  const affectedPaths = [];
+  for (const note of notesWithTag) {
+    const content = await readFile(config.vaultPath, note.path);
+    const updated = replaceTagInContent(content, oldBare, newBare);
+    if (updated !== content) {
+      filesAffected++;
+      affectedPaths.push(note.path);
+      if (!args.dryRun) {
+        await writeFile(config.vaultPath, note.path, updated);
+      }
+    }
+  }
+  return toolJson({
+    filesAffected,
+    affectedPaths,
+    dryRun: args.dryRun ?? false,
+    oldTag: oldNorm,
+    newTag: newNorm
+  });
+}
+function normalizeTag(tag) {
+  const t = tag.toLowerCase().trim();
+  return t.startsWith("#") ? t : `#${t}`;
+}
+function replaceTagInContent(content, oldBare, newBare) {
+  const lines = content.split("\n");
+  let inCodeBlock = false;
+  let frontmatterStart = -1;
+  let frontmatterEnd = -1;
+  if (lines[0]?.trimEnd() === "---") {
+    frontmatterStart = 0;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trimEnd() === "---") {
+        frontmatterEnd = i;
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    if (frontmatterStart >= 0 && i > frontmatterStart && i < frontmatterEnd) {
+      const escaped = escapeRegex2(oldBare);
+      const pattern = new RegExp(`\\b${escaped}\\b`, "gi");
+      lines[i] = lines[i].replace(pattern, newBare);
+      continue;
+    }
+    if (i === frontmatterStart || i === frontmatterEnd) continue;
+    if (lines[i].trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const tagPattern = new RegExp(
+      `#${escapeRegex2(oldBare)}(?=[\\s,;:!?.)\\]}]|$)`,
+      "gi"
+    );
+    lines[i] = lines[i].replace(tagPattern, `#${newBare}`);
+  }
+  return lines.join("\n");
+}
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/tools/folder-tools.ts
+async function listFolder(_cache, config, args) {
+  try {
+    const dirPath = args.path ?? "";
+    const entries = await listDirectory(config.vaultPath, dirPath);
+    return toolJson(entries);
+  } catch (err) {
+    return toolError(`Failed to list folder: ${err.message}`, config.vaultPath);
+  }
+}
+async function moveFolder(cache, config, args) {
+  try {
+    const oldDir = normalizePath(args.path).replace(/\/+$/, "");
+    const newDir = normalizePath(args.newPath).replace(/\/+$/, "");
+    const files = await walkDirectory(config.vaultPath, oldDir);
+    const moves = /* @__PURE__ */ new Map();
+    for (const filePath of files) {
+      const newFilePath = newDir + filePath.slice(oldDir.length);
+      moves.set(filePath, newFilePath);
+    }
+    if (args.dryRun) {
+      return toolJson({
+        dryRun: true,
+        from: oldDir,
+        to: newDir,
+        filesAffected: moves.size,
+        moves: [...moves.entries()].map(([from, to]) => ({ from, to }))
+      });
+    }
+    await moveDirectory(config.vaultPath, oldDir, newDir);
+    for (const [oldPath, newPath] of moves) {
+      cache.mutePath(oldPath);
+      cache.mutePath(newPath);
+    }
+    let linkWarning;
+    let cacheWarning;
+    let linksUpdated = 0;
+    let filesWithUpdatedLinks = [];
+    try {
+      const linkResult = await updateLinksAfterBatchMove(config.vaultPath, cache, moves);
+      linksUpdated = linkResult.updatedCount;
+      filesWithUpdatedLinks = linkResult.updatedFiles;
+    } catch (err) {
+      linkWarning = `Link update failed: ${err.message}. Links may need manual fixing.`;
+      console.error(`[vault-mcp] ${linkWarning}`);
+    }
+    try {
+      const mdMoves = [...moves.entries()].filter(([f]) => f.endsWith(".md"));
+      await cache.reindexPaths(
+        mdMoves.map(([old]) => old),
+        mdMoves.map(([, newP]) => newP)
+      );
+    } catch (err) {
+      cacheWarning = `Cache reindex failed: ${err.message}. Restart server to rebuild cache.`;
+      console.error(`[vault-mcp] ${cacheWarning}`);
+    }
+    const result = {
+      moved: { from: oldDir, to: newDir },
+      filesAffected: moves.size,
+      linksUpdated,
+      filesWithUpdatedLinks
+    };
+    if (linkWarning || cacheWarning) {
+      result.warnings = [linkWarning, cacheWarning].filter(Boolean);
+    }
+    return toolJson(result);
+  } catch (err) {
+    return toolError(`Failed to move folder: ${err.message}`, config.vaultPath);
+  }
+}
+async function deleteFolder(_cache, config, args) {
+  try {
+    await deleteEmptyDirectory(config.vaultPath, args.path);
+    return toolResult(`Deleted empty folder: ${args.path}`);
+  } catch (err) {
+    return toolError(`Failed to delete folder: ${err.message}`, config.vaultPath);
+  }
+}
+async function createFolder(_cache, config, args) {
+  try {
+    await createDirectory(config.vaultPath, args.path);
+    return toolResult(`Created folder: ${args.path}`);
+  } catch (err) {
+    return toolError(`Failed to create folder: ${err.message}`, config.vaultPath);
+  }
+}
+
+// src/tools/vault-tools.ts
+async function vaultInfo(cache, config, _args) {
+  try {
+    return toolJson(cache.getVaultInfo());
+  } catch (err) {
+    return toolError(`Failed to get vault info: ${err.message}`, config.vaultPath);
+  }
+}
+async function vaultStats(cache, config, _args) {
+  try {
+    return toolJson(cache.getStats());
+  } catch (err) {
+    return toolError(`Failed to get vault stats: ${err.message}`, config.vaultPath);
+  }
+}
+async function resolveLink(cache, config, args) {
+  try {
+    const result = cache.resolveLink(args.target);
+    if (!result) {
+      return toolError(`Could not resolve link: ${args.target}`, config.vaultPath);
+    }
+    return toolJson(result);
+  } catch (err) {
+    return toolError(`Failed to resolve link: ${err.message}`, config.vaultPath);
+  }
+}
+
+// src/graph/graph-builder.ts
+function getBacklinks(cache, targetPath) {
+  const results = [];
+  for (const [, note] of cache.notes) {
+    for (const link of note.outgoingLinks) {
+      const resolved = cache.resolveLink(link.target);
+      if (resolved && resolved.path === targetPath) {
+        results.push({
+          sourcePath: note.path,
+          sourceName: note.name,
+          line: link.line,
+          context: ""
+        });
+      }
+    }
+  }
+  return results.sort((a, b) => a.sourcePath.localeCompare(b.sourcePath) || a.line - b.line);
+}
+function getOutgoingLinks(cache, notePath) {
+  const note = cache.getNote(notePath);
+  if (!note) return { resolved: [], unresolved: [] };
+  const resolved = [];
+  const unresolved = [];
+  for (const link of note.outgoingLinks) {
+    const result = cache.resolveLink(link.target);
+    if (result) {
+      resolved.push({
+        target: link.target,
+        path: result.path,
+        name: result.name,
+        line: link.line,
+        isEmbed: link.isEmbed
+      });
+    } else {
+      unresolved.push({
+        target: link.target,
+        line: link.line,
+        isEmbed: link.isEmbed
+      });
+    }
+  }
+  return { resolved, unresolved };
+}
+function getOrphans(cache) {
+  const linkedTo = /* @__PURE__ */ new Set();
+  for (const [, note] of cache.notes) {
+    for (const link of note.outgoingLinks) {
+      const resolved = cache.resolveLink(link.target);
+      if (resolved) linkedTo.add(resolved.path);
+    }
+  }
+  const orphans = [];
+  for (const [notePath, note] of cache.notes) {
+    if (!linkedTo.has(notePath)) {
+      orphans.push({ path: notePath, name: note.name });
+    }
+  }
+  return orphans.sort((a, b) => a.path.localeCompare(b.path));
+}
+function getDeadEnds(cache) {
+  const deadEnds = [];
+  for (const [, note] of cache.notes) {
+    if (note.outgoingLinks.length === 0) {
+      deadEnds.push({ path: note.path, name: note.name });
+    }
+  }
+  return deadEnds.sort((a, b) => a.path.localeCompare(b.path));
+}
+function getUnresolvedLinks(cache) {
+  const results = [];
+  for (const [, note] of cache.notes) {
+    for (const link of note.outgoingLinks) {
+      const resolved = cache.resolveLink(link.target);
+      if (!resolved) {
+        results.push({
+          sourcePath: note.path,
+          sourceName: note.name,
+          target: link.target,
+          line: link.line
+        });
+      }
+    }
+  }
+  return results.sort((a, b) => a.sourcePath.localeCompare(b.sourcePath) || a.line - b.line);
+}
+function getGraphStats(cache) {
+  let totalLinks = 0;
+  let totalUnresolved = 0;
+  const backlinkCounts = /* @__PURE__ */ new Map();
+  const outgoingCounts = /* @__PURE__ */ new Map();
+  const linkedTo = /* @__PURE__ */ new Set();
+  for (const [notePath, note] of cache.notes) {
+    let outCount = 0;
+    for (const link of note.outgoingLinks) {
+      const resolved = cache.resolveLink(link.target);
+      if (resolved) {
+        totalLinks++;
+        outCount++;
+        linkedTo.add(resolved.path);
+        backlinkCounts.set(resolved.path, (backlinkCounts.get(resolved.path) ?? 0) + 1);
+      } else {
+        totalUnresolved++;
+      }
+    }
+    outgoingCounts.set(notePath, outCount);
+  }
+  let orphanCount = 0;
+  for (const notePath of cache.notes.keys()) {
+    if (!linkedTo.has(notePath)) orphanCount++;
+  }
+  let deadEndCount = 0;
+  for (const note of cache.notes.values()) {
+    if (note.outgoingLinks.length === 0) deadEndCount++;
+  }
+  const mostLinkedTo = [...backlinkCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([p, count]) => {
+    const note = cache.getNote(p);
+    return { path: p, name: note?.name ?? p, count };
+  });
+  const mostLinkingFrom = [...outgoingCounts.entries()].filter(([, count]) => count > 0).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([p, count]) => {
+    const note = cache.getNote(p);
+    return { path: p, name: note?.name ?? p, count };
+  });
+  return {
+    totalNotes: cache.notes.size,
+    totalLinks,
+    totalUnresolved,
+    orphanCount,
+    deadEndCount,
+    mostLinkedTo,
+    mostLinkingFrom
+  };
+}
+
+// src/tools/graph-tools.ts
+async function getLinks(cache, config, args) {
+  const note = cache.getNote(args.path);
+  if (!note) {
+    return toolError(`Note not found: ${args.path}`, config.vaultPath);
+  }
+  const links = getOutgoingLinks(cache, args.path);
+  return toolJson(links);
+}
+async function getBacklinksHandler(cache, config, args) {
+  const note = cache.getNote(args.path);
+  if (!note) {
+    return toolError(`Note not found: ${args.path}`, config.vaultPath);
+  }
+  const backlinks = getBacklinks(cache, args.path);
+  if (args.includeContext) {
+    for (const entry of backlinks) {
+      try {
+        const content = await readFile(config.vaultPath, entry.sourcePath);
+        const { body } = parseFrontmatter(content);
+        const bodyLines = body.split("\n");
+        if (entry.line >= 0 && entry.line < bodyLines.length) {
+          entry.context = bodyLines[entry.line];
+        }
+      } catch {
+      }
+    }
+  }
+  return toolJson(backlinks);
+}
+async function getOrphansHandler(cache, _config, _args) {
+  return toolJson(getOrphans(cache));
+}
+async function getDeadEndsHandler(cache, _config, _args) {
+  return toolJson(getDeadEnds(cache));
+}
+async function getUnresolvedHandler(cache, _config, _args) {
+  return toolJson(getUnresolvedLinks(cache));
+}
+
+// src/parsers/canvas.ts
+var VALID_NODE_TYPES = /* @__PURE__ */ new Set(["text", "file", "link", "group"]);
+var VALID_SIDES = /* @__PURE__ */ new Set(["top", "right", "bottom", "left"]);
+function parseCanvas(content) {
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw;
+  const rawNodes = Array.isArray(obj.nodes) ? obj.nodes : [];
+  const rawEdges = Array.isArray(obj.edges) ? obj.edges : [];
+  const nodes = [];
+  for (const n of rawNodes) {
+    if (typeof n !== "object" || n === null) continue;
+    const node = n;
+    if (typeof node.id !== "string") continue;
+    if (typeof node.type !== "string" || !VALID_NODE_TYPES.has(node.type)) continue;
+    if (typeof node.x !== "number" || typeof node.y !== "number") continue;
+    if (typeof node.width !== "number" || typeof node.height !== "number") continue;
+    const parsed = {
+      id: node.id,
+      type: node.type,
+      x: node.x,
+      y: node.y,
+      width: node.width,
+      height: node.height
+    };
+    if (typeof node.text === "string") parsed.text = node.text;
+    if (typeof node.file === "string") parsed.file = node.file;
+    if (typeof node.url === "string") parsed.url = node.url;
+    if (typeof node.label === "string") parsed.label = node.label;
+    if (typeof node.color === "string") parsed.color = node.color;
+    nodes.push(parsed);
+  }
+  const edges = [];
+  for (const e of rawEdges) {
+    if (typeof e !== "object" || e === null) continue;
+    const edge = e;
+    if (typeof edge.id !== "string") continue;
+    if (typeof edge.fromNode !== "string" || typeof edge.toNode !== "string") continue;
+    const parsed = {
+      id: edge.id,
+      fromNode: edge.fromNode,
+      toNode: edge.toNode
+    };
+    if (typeof edge.fromSide === "string" && VALID_SIDES.has(edge.fromSide)) {
+      parsed.fromSide = edge.fromSide;
+    }
+    if (typeof edge.toSide === "string" && VALID_SIDES.has(edge.toSide)) {
+      parsed.toSide = edge.toSide;
+    }
+    if (typeof edge.label === "string") parsed.label = edge.label;
+    if (typeof edge.color === "string") parsed.color = edge.color;
+    edges.push(parsed);
+  }
+  return { nodes, edges };
+}
+
+// src/tools/canvas-tools.ts
+import fs3 from "fs/promises";
+import path6 from "path";
+async function readCanvas(_cache, config, args) {
+  try {
+    if (!args.path.endsWith(".canvas")) {
+      return toolError("Path must end with .canvas", config.vaultPath);
+    }
+    const absPath = resolveVaultPath(config.vaultPath, args.path);
+    const content = await fs3.readFile(absPath, "utf-8");
+    const parsed = parseCanvas(content);
+    if (!parsed) {
+      return toolError(`Failed to parse canvas file: ${args.path}`, config.vaultPath);
+    }
+    return toolJson(parsed);
+  } catch (err) {
+    return toolError(`Failed to read canvas: ${err.message}`, config.vaultPath);
+  }
+}
+async function listCanvases(_cache, config, _args) {
+  try {
+    const canvases = [];
+    await walkDir(config.vaultPath, config.vaultPath, canvases);
+    return toolJson(canvases);
+  } catch (err) {
+    return toolError(`Failed to list canvases: ${err.message}`, config.vaultPath);
+  }
+}
+async function walkDir(root, dir, results) {
+  const entries = await fs3.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path6.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      await walkDir(root, fullPath, results);
+    } else if (entry.name.endsWith(".canvas")) {
+      const relPath = path6.relative(root, fullPath).replace(/\\/g, "/");
+      const stat = await fs3.stat(fullPath);
+      results.push({
+        path: relPath,
+        name: path6.basename(entry.name, ".canvas"),
+        size: stat.size
+      });
+    }
+  }
+}
+
+// src/parsers/bookmarks.ts
+var VALID_BOOKMARK_TYPES = /* @__PURE__ */ new Set(["file", "folder", "group", "search", "graph"]);
+function parseBookmarks(content) {
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  if (typeof raw !== "object" || raw === null) return [];
+  const obj = raw;
+  if (!Array.isArray(obj.items)) return [];
+  return parseItems(obj.items);
+}
+function parseItems(items) {
+  const result = [];
+  for (const item of items) {
+    if (typeof item !== "object" || item === null) continue;
+    const obj = item;
+    if (typeof obj.type !== "string" || !VALID_BOOKMARK_TYPES.has(obj.type)) continue;
+    const parsed = {
+      type: obj.type
+    };
+    if (typeof obj.title === "string") parsed.title = obj.title;
+    if (typeof obj.path === "string") parsed.path = obj.path;
+    if (typeof obj.query === "string") parsed.query = obj.query;
+    if (typeof obj.subpath === "string") parsed.subpath = obj.subpath;
+    if (typeof obj.ctime === "number") parsed.ctime = obj.ctime;
+    if (Array.isArray(obj.items)) {
+      parsed.items = parseItems(obj.items);
+    }
+    result.push(parsed);
+  }
+  return result;
+}
+
+// src/tools/bookmark-tools.ts
+import fs4 from "fs/promises";
+import path7 from "path";
+async function getBookmarksHandler(_cache, config, _args) {
+  try {
+    const absPath = path7.join(config.vaultPath, ".obsidian", "bookmarks.json");
+    const content = await fs4.readFile(absPath, "utf-8");
+    const bookmarks = parseBookmarks(content);
+    return toolJson(bookmarks);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return toolJson([]);
+    }
+    return toolError(`Failed to read bookmarks: ${err.message}`, config.vaultPath);
+  }
+}
+
+// src/rest/rest-client.ts
+import https from "https";
+var agent = new https.Agent({ rejectUnauthorized: false });
+function restRequest(url, options) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const req = https.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname + parsed.search,
+        method: options.method,
+        headers: options.headers,
+        agent,
+        timeout: options.timeout
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          resolve({
+            status: res.statusCode ?? 0,
+            body: Buffer.concat(chunks).toString("utf-8")
+          });
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+    if (options.body) {
+      req.write(options.body);
+    }
+    req.end();
+  });
+}
+function buildHeaders(config) {
+  const headers = {};
+  if (config.restToken) {
+    headers["Authorization"] = `Bearer ${config.restToken}`;
+  }
+  return headers;
+}
+function baseUrl(config) {
+  return `https://127.0.0.1:${config.restPort}`;
+}
+async function restListCommands(config) {
+  const url = `${baseUrl(config)}/commands/`;
+  const response = await restRequest(url, {
+    method: "GET",
+    headers: buildHeaders(config)
+  });
+  if (response.status !== 200) {
+    throw new Error(`REST list commands failed (${response.status}): ${response.body}`);
+  }
+  const data = JSON.parse(response.body);
+  return data.commands ?? [];
+}
+async function restExecuteCommand(config, commandId) {
+  const url = `${baseUrl(config)}/commands/${encodeURIComponent(commandId)}/`;
+  const response = await restRequest(url, {
+    method: "POST",
+    headers: buildHeaders(config)
+  });
+  if (response.status !== 204 && response.status !== 200) {
+    throw new Error(`REST execute command failed (${response.status}): ${response.body}`);
+  }
+}
+async function restOpenNote(config, notePath) {
+  const url = `${baseUrl(config)}/open/${encodeURIComponent(notePath)}`;
+  const response = await restRequest(url, {
+    method: "POST",
+    headers: buildHeaders(config)
+  });
+  if (response.status !== 204 && response.status !== 200) {
+    throw new Error(`REST open note failed (${response.status}): ${response.body}`);
+  }
+}
+
+// src/tools/rest-tools.ts
+async function executeCommand(config, args) {
+  try {
+    await restExecuteCommand(config, args.commandId);
+    return toolResult(`Executed command: ${args.commandId}`);
+  } catch (err) {
+    return toolError(`Failed to execute command: ${err.message}`, config.vaultPath);
+  }
+}
+async function listCommands(config, _args) {
+  try {
+    const commands = await restListCommands(config);
+    return toolJson(commands);
+  } catch (err) {
+    return toolError(`Failed to list commands: ${err.message}`, config.vaultPath);
+  }
+}
+async function openInObsidian(config, args) {
+  try {
+    await restOpenNote(config, args.path);
+    return toolResult(`Opened in Obsidian: ${args.path}`);
+  } catch (err) {
+    return toolError(`Failed to open in Obsidian: ${err.message}`, config.vaultPath);
+  }
+}
+
+// src/tools/register-tools.ts
+var MAX_PATH = 4096;
+var MAX_CONTENT = 10 * 1024 * 1024;
+var MAX_QUERY = 1e4;
+var MAX_TAG = 200;
+var MAX_PROPERTY_KEY = 200;
+var MAX_COMMAND_ID = 200;
+function registerAllTools(server, cache, config) {
+  server.registerTool("vault_read_note", {
+    title: "Read Note",
+    description: "Read a note's content and metadata by path. Returns frontmatter, body content, tags, and headings.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note, e.g. 'folder/note.md'")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => readNote(cache, config, args));
+  server.registerTool("vault_create_note", {
+    title: "Create Note",
+    description: "Create a new note at the specified path. Fails if the note already exists.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path for the new note, e.g. 'folder/new-note.md'"),
+      content: z.string().max(MAX_CONTENT).describe("Body content of the note (markdown)"),
+      frontmatter: z.record(z.unknown()).optional().describe("Optional YAML frontmatter as key-value pairs")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => createNote(cache, config, args));
+  server.registerTool("vault_update_note", {
+    title: "Update Note",
+    description: "Replace a note's entire content. Optionally replace frontmatter. Fails if the note does not exist.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note"),
+      content: z.string().max(MAX_CONTENT).describe("New body content (replaces everything below frontmatter)"),
+      frontmatter: z.record(z.unknown()).optional().describe("Optional new frontmatter (replaces existing if provided)")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => updateNote(cache, config, args));
+  server.registerTool("vault_patch_note", {
+    title: "Patch Note",
+    description: "Surgical edit: append, prepend, or replace content at a target location (whole file, heading section, block, or frontmatter key). The precision editing tool.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note"),
+      content: z.string().max(MAX_CONTENT).describe("Content to insert or replace with"),
+      operation: z.enum(["append", "prepend", "replace"]).describe("How to apply the content"),
+      targetType: z.enum(["heading", "block", "frontmatter"]).optional().describe("Type of target to operate on. Omit for whole-file operation."),
+      target: z.string().max(MAX_PATH).optional().describe("Target identifier: heading text, ^block-id, or frontmatter key. Required when targetType is set.")
+    },
+    annotations: { readOnlyHint: false, idempotentHint: true }
+  }, async (args) => patchNote(cache, config, args));
+  server.registerTool("vault_delete_note", {
+    title: "Delete Note",
+    description: "Permanently delete a note. This cannot be undone.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note to delete")
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true }
+  }, async (args) => deleteNote(cache, config, args));
+  server.registerTool("vault_search", {
+    title: "Search Vault",
+    description: "Full-text search across all notes in the vault. Returns matching notes with line-level context.",
+    inputSchema: {
+      query: z.string().max(MAX_QUERY).describe("Search query (case-insensitive substring match)"),
+      limit: z.number().int().min(1).max(100).optional().describe("Max results to return (default: 20)")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => search(cache, config, args));
+  server.registerTool("vault_search_by_tag", {
+    title: "Search by Tag",
+    description: "Find all notes with a specific tag (checks both frontmatter and inline tags).",
+    inputSchema: {
+      tag: z.string().max(MAX_TAG).describe("Tag to search for, e.g. '#project' or 'project' (# prefix optional)")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => searchByTag(cache, config, args));
+  server.registerTool("vault_search_by_frontmatter", {
+    title: "Search by Frontmatter",
+    description: "Find notes where a specific frontmatter property exists or matches a value.",
+    inputSchema: {
+      key: z.string().max(MAX_PROPERTY_KEY).describe("Frontmatter property key to search for"),
+      value: z.unknown().optional().describe("Optional value to match. If omitted, finds notes where the key exists.")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => searchByFrontmatter(cache, config, args));
+  server.registerTool("vault_search_structured", {
+    title: "Structured Search",
+    description: "Power-search combining text query, tag filter, frontmatter filter, and folder scope. All filters are AND-combined. Returns matching notes sorted by relevance or specified field.",
+    inputSchema: {
+      query: z.string().max(MAX_QUERY).optional().describe("Text search query (case-insensitive). Searches note content."),
+      tags: z.array(z.string().max(MAX_TAG)).optional().describe("Filter to notes with ALL of these tags. # prefix optional."),
+      frontmatter: z.array(z.object({
+        key: z.string().max(MAX_PROPERTY_KEY).describe("Frontmatter property key"),
+        value: z.unknown().optional().describe("Value to match. Omit to match any value.")
+      })).optional().describe("Filter by frontmatter properties. All must match."),
+      folder: z.string().max(MAX_PATH).optional().describe("Restrict search to this folder (recursive). e.g. 'Projects/'"),
+      sort: z.enum(["modified", "created", "name", "size"]).optional().describe("Sort field (default: modified)"),
+      sortOrder: z.enum(["asc", "desc"]).optional().describe("Sort direction (default: desc for dates/size, asc for name)"),
+      limit: z.number().int().min(1).max(100).optional().describe("Max results (default: 20)")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => searchStructured(cache, config, args));
+  server.registerTool("vault_get_properties", {
+    title: "Get Properties",
+    description: "Get all frontmatter properties of a note as a JSON object.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => getProperties(cache, config, args));
+  server.registerTool("vault_set_property", {
+    title: "Set Property",
+    description: "Set a frontmatter property on a note. Creates frontmatter if none exists. Overwrites existing values.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note"),
+      key: z.string().max(MAX_PROPERTY_KEY).describe("Property key to set"),
+      value: z.unknown().describe("Property value (string, number, boolean, array, or object)")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => setProperty(cache, config, args));
+  server.registerTool("vault_remove_property", {
+    title: "Remove Property",
+    description: "Remove a frontmatter property from a note.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note"),
+      key: z.string().max(MAX_PROPERTY_KEY).describe("Property key to remove")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => removeProperty(cache, config, args));
+  server.registerTool("vault_list_tags", {
+    title: "List Tags",
+    description: "List all tags used across the vault with the number of notes each appears in.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  }, async () => listTags(cache, config, {}));
+  server.registerTool("vault_get_note_tags", {
+    title: "Get Note Tags",
+    description: "Get all tags (frontmatter + inline) for a specific note.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => getNoteTags(cache, config, args));
+  server.registerTool("vault_list_folder", {
+    title: "List Folder",
+    description: "List files and subfolders in a vault directory. Defaults to vault root.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).optional().describe("Relative folder path (default: vault root)")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => listFolder(cache, config, args));
+  server.registerTool("vault_create_folder", {
+    title: "Create Folder",
+    description: "Create a new folder in the vault. Creates parent directories if needed.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path for the new folder")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => createFolder(cache, config, args));
+  server.registerTool("vault_move_folder", {
+    title: "Move Folder",
+    description: "Move or rename a folder. Automatically updates all wikilinks that reference files in the moved folder. Use dryRun to preview changes.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Current relative path of the folder to move"),
+      newPath: z.string().max(MAX_PATH).describe("New relative path for the folder"),
+      dryRun: z.boolean().optional().describe("Preview changes without moving (default: false)")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => moveFolder(cache, config, args));
+  server.registerTool("vault_delete_folder", {
+    title: "Delete Folder",
+    description: "Delete an empty folder. Refuses to delete folders that contain files \u2014 move or delete contents first.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path of the empty folder to delete")
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true }
+  }, async (args) => deleteFolder(cache, config, args));
+  server.registerTool("vault_info", {
+    title: "Vault Info",
+    description: "Get basic information about the connected vault: name and note/folder counts.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  }, async () => vaultInfo(cache, config, {}));
+  server.registerTool("vault_stats", {
+    title: "Vault Stats",
+    description: "Get detailed statistics about the vault: note counts, tag counts, sizes, oldest/newest/largest notes.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  }, async () => vaultStats(cache, config, {}));
+  server.registerTool("vault_resolve_link", {
+    title: "Resolve Link",
+    description: "Resolve a wikilink target to its actual file path using Obsidian's link resolution rules. Handles ambiguous names.",
+    inputSchema: {
+      target: z.string().max(MAX_PATH).describe("Link target to resolve, e.g. 'note', 'folder/note', '[[note]]', 'note#heading'"),
+      fromPath: z.string().max(MAX_PATH).optional().describe("Path of the note containing the link (for relative resolution, reserved for future use)")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => resolveLink(cache, config, args));
+  server.registerTool("vault_move_note", {
+    title: "Move Note",
+    description: "Move a note to a new path. Automatically updates all wikilinks in other notes that point to it.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Current relative path of the note"),
+      newPath: z.string().max(MAX_PATH).describe("Destination relative path")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => moveNote(cache, config, args));
+  server.registerTool("vault_rename_note", {
+    title: "Rename Note",
+    description: "Rename a note (stays in the same folder). Automatically updates all wikilinks in other notes.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Current relative path of the note"),
+      newName: z.string().max(MAX_PATH).describe("New filename (with or without .md extension)")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => renameNote(cache, config, args));
+  server.registerTool("vault_rename_tag", {
+    title: "Rename Tag",
+    description: "Rename a tag across the entire vault. Supports dry-run mode to preview changes.",
+    inputSchema: {
+      oldTag: z.string().max(MAX_TAG).describe("Tag to rename (with or without #)"),
+      newTag: z.string().max(MAX_TAG).describe("New tag name (with or without #)"),
+      dryRun: z.boolean().optional().describe("Preview changes without writing (default: false)")
+    },
+    annotations: { readOnlyHint: false }
+  }, async (args) => renameTag(cache, config, args));
+  server.registerTool("vault_get_links", {
+    title: "Get Links",
+    description: "Get all outgoing links from a note, separated into resolved (found in vault) and unresolved (broken) links.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the note")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => getLinks(cache, config, args));
+  server.registerTool("vault_get_backlinks", {
+    title: "Get Backlinks",
+    description: "Get all notes that link TO a given note. Optionally includes the line of text containing each link.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the target note"),
+      includeContext: z.boolean().optional().describe("Include the source line text for each backlink (default: false)")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => getBacklinksHandler(cache, config, args));
+  server.registerTool("vault_get_orphans", {
+    title: "Get Orphans",
+    description: "Find notes with zero incoming links \u2014 no other note links to them.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  }, async () => getOrphansHandler(cache, config, {}));
+  server.registerTool("vault_get_dead_ends", {
+    title: "Get Dead Ends",
+    description: "Find notes with zero outgoing links \u2014 they don't link to anything.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  }, async () => getDeadEndsHandler(cache, config, {}));
+  server.registerTool("vault_get_unresolved", {
+    title: "Get Unresolved Links",
+    description: "Find all broken wikilinks across the vault \u2014 links that don't match any note.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  }, async () => getUnresolvedHandler(cache, config, {}));
+  server.registerTool("vault_read_canvas", {
+    title: "Read Canvas",
+    description: "Read and parse an Obsidian canvas file into structured JSON with nodes and edges.",
+    inputSchema: {
+      path: z.string().max(MAX_PATH).describe("Relative path to the .canvas file")
+    },
+    annotations: { readOnlyHint: true }
+  }, async (args) => readCanvas(cache, config, args));
+  server.registerTool("vault_list_canvases", {
+    title: "List Canvases",
+    description: "List all .canvas files in the vault.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  }, async () => listCanvases(cache, config, {}));
+  server.registerTool("vault_get_bookmarks", {
+    title: "Get Bookmarks",
+    description: "Read the Obsidian bookmark tree from bookmarks.json.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  }, async () => getBookmarksHandler(cache, config, {}));
+  if (config.restAvailable) {
+    server.registerTool("vault_execute_command", {
+      title: "Execute Command",
+      description: "Execute an Obsidian command by ID. Requires Obsidian to be running with the REST API plugin.",
+      inputSchema: {
+        commandId: z.string().max(MAX_COMMAND_ID).regex(/^[a-zA-Z0-9_:.\-]+$/, "Invalid command ID format").describe("Command ID to execute (e.g. 'app:toggle-left-sidebar')")
+      },
+      annotations: { readOnlyHint: false, openWorldHint: true }
+    }, async (args) => executeCommand(config, args));
+    server.registerTool("vault_list_commands", {
+      title: "List Commands",
+      description: "List all registered Obsidian commands. Requires Obsidian to be running with the REST API plugin.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    }, async () => listCommands(config, {}));
+    server.registerTool("vault_open_in_obsidian", {
+      title: "Open in Obsidian",
+      description: "Open a note in the Obsidian UI. Requires Obsidian to be running with the REST API plugin.",
+      inputSchema: {
+        path: z.string().max(MAX_PATH).describe("Relative path to the note to open")
+      },
+      annotations: { readOnlyHint: false, openWorldHint: true }
+    }, async (args) => openInObsidian(config, args));
+  }
+}
+
+// src/resources/register-resources.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerAllResources(server, cache, config) {
+  server.registerResource(
+    "vault-info",
+    "obsidian://vault/info",
+    {
+      title: "Vault Info",
+      description: "Basic information about the connected Obsidian vault",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        text: JSON.stringify(cache.getVaultInfo(), null, 2),
+        mimeType: "application/json"
+      }]
+    })
+  );
+  server.registerResource(
+    "note",
+    new ResourceTemplate("obsidian://note/{path}", {
+      list: async () => {
+        const resources = Array.from(cache.notes.values()).map((note) => ({
+          uri: `obsidian://note/${note.path}`,
+          name: note.name,
+          description: `Note: ${note.path}`,
+          mimeType: "text/markdown"
+        }));
+        return { resources };
+      }
+    }),
+    {
+      title: "Note Content",
+      description: "Read a specific note by its vault-relative path",
+      mimeType: "text/markdown"
+    },
+    async (uri, { path: path9 }) => {
+      const decodedPath = decodeURIComponent(path9);
+      const content = await readFile(config.vaultPath, decodedPath);
+      return {
+        contents: [{
+          uri: uri.href,
+          text: content,
+          mimeType: "text/markdown"
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "tags",
+    "obsidian://tags",
+    {
+      title: "All Tags",
+      description: "List of all tags used in the vault with note counts",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        text: JSON.stringify(cache.getAllTags(), null, 2),
+        mimeType: "application/json"
+      }]
+    })
+  );
+  server.registerResource(
+    "recent",
+    "obsidian://recent",
+    {
+      title: "Recent Notes",
+      description: "The 20 most recently modified notes in the vault",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const recent = cache.getRecentNotes(20).map((note) => ({
+        path: note.path,
+        name: note.name,
+        modified: note.modified
+      }));
+      return {
+        contents: [{
+          uri: uri.href,
+          text: JSON.stringify(recent, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+}
+
+// src/resources/register-subscriptions.ts
+import fs5 from "fs/promises";
+import path8 from "path";
+function registerPhase2Resources(server, cache, config) {
+  server.registerResource(
+    "vault-structure",
+    "obsidian://vault/structure",
+    {
+      title: "Vault Structure",
+      description: "Full folder tree of the vault as JSON",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const folders = /* @__PURE__ */ new Set();
+      for (const notePath of cache.notes.keys()) {
+        const parts = notePath.split("/");
+        for (let i = 1; i < parts.length; i++) {
+          folders.add(parts.slice(0, i).join("/"));
+        }
+      }
+      const sorted = [...folders].sort();
+      return {
+        contents: [{
+          uri: uri.href,
+          text: JSON.stringify({ folders: sorted, noteCount: cache.notes.size }, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "graph-summary",
+    "obsidian://graph/summary",
+    {
+      title: "Graph Summary",
+      description: "Knowledge graph statistics and most-connected notes",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const stats = getGraphStats(cache);
+      return {
+        contents: [{
+          uri: uri.href,
+          text: JSON.stringify(stats, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "bookmarks",
+    "obsidian://bookmarks",
+    {
+      title: "Bookmarks",
+      description: "Obsidian bookmark tree from bookmarks.json",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      try {
+        const absPath = path8.join(config.vaultPath, ".obsidian", "bookmarks.json");
+        const content = await fs5.readFile(absPath, "utf-8");
+        const bookmarks = parseBookmarks(content);
+        return {
+          contents: [{
+            uri: uri.href,
+            text: JSON.stringify(bookmarks, null, 2),
+            mimeType: "application/json"
+          }]
+        };
+      } catch {
+        return {
+          contents: [{
+            uri: uri.href,
+            text: JSON.stringify([], null, 2),
+            mimeType: "application/json"
+          }]
+        };
+      }
+    }
+  );
+}
+
+// src/prompts/register-prompts.ts
+import { z as z2 } from "zod";
+function registerAllPrompts(server, cache, config) {
+  server.registerPrompt(
+    "daily_note_summary",
+    {
+      title: "Daily Note Summary",
+      description: "Summarize today's daily note (or a specific date)",
+      argsSchema: {
+        date: z2.string().optional().describe("Date in YYYY-MM-DD format (default: today)")
+      }
+    },
+    async ({ date }) => {
+      const targetDate = date ?? (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const notePath = `Daily Notes/${targetDate}.md`;
+      let content;
+      try {
+        content = await readFile(config.vaultPath, notePath);
+      } catch {
+        content = `No daily note found for ${targetDate}.`;
+      }
+      return {
+        messages: [{
+          role: "user",
+          content: { type: "text", text: `Summarize this daily note for ${targetDate}:
+
+${content}` }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "vault_health_check",
+    {
+      title: "Vault Health Check",
+      description: "Audit orphans, dead-ends, unresolved links, and tag hygiene"
+    },
+    async () => {
+      const stats = getGraphStats(cache);
+      const orphans = getOrphans(cache);
+      const deadEnds = getDeadEnds(cache);
+      const unresolved = getUnresolvedLinks(cache);
+      const allTags = cache.getAllTags();
+      const report = JSON.stringify({
+        graphStats: stats,
+        orphanSample: orphans.slice(0, 20),
+        deadEndSample: deadEnds.slice(0, 20),
+        unresolvedSample: unresolved.slice(0, 20),
+        tagCount: allTags.length,
+        singleUseTags: allTags.filter((t) => t.count === 1).map((t) => t.tag)
+      }, null, 2);
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: `Analyze this vault health report. Identify issues, suggest fixes, and prioritize by impact:
+
+${report}`
+          }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "note_connections",
+    {
+      title: "Note Connections",
+      description: "Analyze a note's position in the knowledge graph and suggest new connections",
+      argsSchema: {
+        path: z2.string().describe("Path to the note to analyze")
+      }
+    },
+    async ({ path: path9 }) => {
+      const meta = cache.getNote(path9);
+      if (!meta) {
+        return {
+          messages: [{
+            role: "user",
+            content: { type: "text", text: `Note not found: ${path9}` }
+          }]
+        };
+      }
+      const outgoing = getOutgoingLinks(cache, path9);
+      const backlinks = getBacklinks(cache, path9);
+      let content;
+      try {
+        content = await readFile(config.vaultPath, path9);
+      } catch {
+        content = "(could not read note content)";
+      }
+      const analysis = JSON.stringify({
+        note: { path: meta.path, name: meta.name, tags: meta.tags },
+        outgoingResolved: outgoing.resolved.length,
+        outgoingUnresolved: outgoing.unresolved,
+        backlinkCount: backlinks.length,
+        backlinks: backlinks.slice(0, 10)
+      }, null, 2);
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: `Analyze this note's connections in the knowledge graph. Suggest new links to existing notes that would strengthen the graph:
+
+Note content:
+${content.substring(0, 2e3)}
+
+Graph data:
+${analysis}`
+          }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "research_and_link",
+    {
+      title: "Research and Link",
+      description: "Find related notes on a topic and suggest wikilinks to add",
+      argsSchema: {
+        topic: z2.string().describe("Topic to research within the vault")
+      }
+    },
+    async ({ topic }) => {
+      const searchResults = await cache.searchContent(topic);
+      const topResults = searchResults.slice(0, 15).map((r) => ({
+        path: r.path,
+        name: r.name,
+        matchCount: r.matches.length,
+        sampleMatch: r.matches[0]?.text ?? ""
+      }));
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: `I'm researching "${topic}" in my vault. Here are notes that mention it:
+
+${JSON.stringify(topResults, null, 2)}
+
+Suggest which notes should link to each other and what wikilinks to add.`
+          }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "inbox_triage",
+    {
+      title: "Inbox Triage",
+      description: "List unprocessed inbox files with routing suggestions"
+    },
+    async () => {
+      const inboxNotes = [];
+      for (const [path9, meta] of cache.notes) {
+        if (path9.startsWith("_Inbox/")) {
+          inboxNotes.push({ path: path9, name: meta.name, size: meta.size });
+        }
+      }
+      if (inboxNotes.length === 0) {
+        return {
+          messages: [{
+            role: "user",
+            content: { type: "text", text: "Inbox is empty \u2014 nothing to triage." }
+          }]
+        };
+      }
+      const previews = [];
+      for (const note of inboxNotes.slice(0, 20)) {
+        try {
+          const content = await readFile(config.vaultPath, note.path);
+          previews.push({ path: note.path, name: note.name, preview: content.substring(0, 500) });
+        } catch {
+          previews.push({ path: note.path, name: note.name, preview: "(unreadable)" });
+        }
+      }
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: `Triage these ${inboxNotes.length} inbox items. For each, suggest where it should be filed and what tags to apply:
+
+${JSON.stringify(previews, null, 2)}`
+          }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "weekly_review",
+    {
+      title: "Weekly Review",
+      description: "Summarize the week's daily notes, tasks completed, and ideas captured",
+      argsSchema: {
+        startDate: z2.string().optional().describe("Start date (YYYY-MM-DD). Defaults to 7 days ago.")
+      }
+    },
+    async ({ startDate }) => {
+      const start = startDate ? new Date(startDate) : new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3);
+      const dailyNotes = [];
+      for (let i = 0; i < 7; i++) {
+        const d = new Date(start.getTime() + i * 24 * 60 * 60 * 1e3);
+        const dateStr = d.toISOString().split("T")[0];
+        const notePath = `Daily Notes/${dateStr}.md`;
+        try {
+          const content = await readFile(config.vaultPath, notePath);
+          dailyNotes.push({ date: dateStr, preview: content.substring(0, 1e3) });
+        } catch {
+        }
+      }
+      if (dailyNotes.length === 0) {
+        return {
+          messages: [{
+            role: "user",
+            content: { type: "text", text: "No daily notes found for this week." }
+          }]
+        };
+      }
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: `Summarize this week's activity from my daily notes. Highlight key accomplishments, recurring themes, and anything that seems unfinished:
+
+${JSON.stringify(dailyNotes, null, 2)}`
+          }
+        }]
+      };
+    }
+  );
+}
+
+// src/rest/rest-probe.ts
+import https2 from "https";
+var agent2 = new https2.Agent({ rejectUnauthorized: false });
+async function probeRestApi(config) {
+  if (!config.restToken) {
+    console.error("[vault-mcp] REST API: not configured (no OBSIDIAN_REST_TOKEN)");
+    return false;
+  }
+  try {
+    const result = await new Promise((resolve) => {
+      const req = https2.request(
+        {
+          hostname: "127.0.0.1",
+          port: config.restPort,
+          path: "/",
+          method: "GET",
+          headers: { Authorization: `Bearer ${config.restToken}` },
+          agent: agent2,
+          timeout: 2e3
+        },
+        (res) => {
+          res.on("data", () => {
+          });
+          res.on("end", () => {
+            resolve(res.statusCode === 200);
+          });
+        }
+      );
+      req.on("error", () => resolve(false));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(false);
+      });
+      req.end();
+    });
+    console.error(`[vault-mcp] REST API: ${result ? "available" : "not available"}`);
+    return result;
+  } catch {
+    console.error("[vault-mcp] REST API: not available");
+    return false;
+  }
+}
+
+// src/transport/create-transport.ts
+import http from "http";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+var MAX_BODY_SIZE = 10 * 1024 * 1024;
+async function connectTransport(server, config) {
+  if (config.transport === "stdio") {
+    const transport2 = new StdioServerTransport();
+    await server.connect(transport2);
+    return {
+      shutdown: async () => {
+        await transport2.close();
+      }
+    };
+  }
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: void 0
+  });
+  await server.connect(transport);
+  const httpServer = http.createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST, GET, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://localhost:${config.httpPort}`);
+    if (url.pathname !== "/mcp") {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found. Use /mcp endpoint." }));
+      return;
+    }
+    if (config.httpAuthToken) {
+      const authHeader = req.headers.authorization;
+      if (!authHeader || authHeader !== `Bearer ${config.httpAuthToken}`) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Unauthorized" }));
+        return;
+      }
+    }
+    try {
+      if (req.method === "POST") {
+        const body = await readRequestBody(req, MAX_BODY_SIZE);
+        await transport.handleRequest(req, res, body);
+      } else if (req.method === "GET" || req.method === "DELETE") {
+        await transport.handleRequest(req, res);
+      } else {
+        res.writeHead(405, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Method not allowed" }));
+      }
+    } catch (err) {
+      if (!res.headersSent) {
+        const message = err.message;
+        if (message === "Request body too large") {
+          res.writeHead(413, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Request body too large (max 10MB)" }));
+        } else {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+      }
+    }
+  });
+  await new Promise((resolve) => {
+    httpServer.listen(config.httpPort, () => {
+      console.error(`[vault-mcp] HTTP transport listening on port ${config.httpPort}`);
+      resolve();
+    });
+  });
+  return {
+    shutdown: async () => {
+      await transport.close();
+      await new Promise((resolve) => {
+        httpServer.close(() => resolve());
+      });
+    }
+  };
+}
+function readRequestBody(req, maxSize) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > maxSize) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      data += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        resolve(data ? JSON.parse(data) : void 0);
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+// src/index.ts
+var arg = process.argv[2];
+if (arg === "--help" || arg === "-h") {
+  console.log(`vault-mcp-tools v1.0.0 \u2014 MCP server for Obsidian vault interaction
+
+Usage:
+  OBSIDIAN_VAULT_PATH="/path/to/vault" vault-mcp-tools
+
+Environment variables:
+  OBSIDIAN_VAULT_PATH       (required) Absolute path to your Obsidian vault
+  OBSIDIAN_REST_TOKEN       Bearer token for Obsidian Local REST API plugin
+  OBSIDIAN_REST_PORT        REST API port (default: 27124)
+  OBSIDIAN_TRANSPORT        Transport mode: stdio (default) or http
+  OBSIDIAN_HTTP_PORT        HTTP server port (default: 3000)
+  OBSIDIAN_HTTP_AUTH_TOKEN  Bearer token for HTTP transport authentication
+
+Documentation: https://github.com/afable702/obsidian-mcp-server`);
+  process.exit(0);
+}
+if (arg === "--version" || arg === "-v") {
+  console.log("1.0.0");
+  process.exit(0);
+}
+async function main() {
+  const config = loadConfig();
+  config.restAvailable = await probeRestApi(config);
+  const cache = new MetadataCache(config.vaultPath);
+  await cache.initialize();
+  cache.startWatching();
+  const server = new McpServer({
+    name: "vault-mcp",
+    version: "1.0.0"
+  });
+  registerAllTools(server, cache, config);
+  registerAllResources(server, cache, config);
+  registerPhase2Resources(server, cache, config);
+  registerAllPrompts(server, cache, config);
+  const { shutdown: shutdownTransport } = await connectTransport(server, config);
+  const restStatus = config.restAvailable ? "available" : "not available";
+  const authStatus = config.httpAuthToken ? "auth: enabled" : "auth: none";
+  console.error(`[vault-mcp] Server started. Vault: ${config.vaultPath} (${cache.notes.size} notes, REST: ${restStatus}, transport: ${config.transport}, ${authStatus})`);
+  const shutdown = async () => {
+    console.error("[vault-mcp] Shutting down...");
+    await cache.stopWatching();
+    await shutdownTransport();
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  if (err && err.code === "CONFIG_MISSING") {
+    console.error(`[vault-mcp] ${err.message}`);
+    console.error("[vault-mcp] Run 'vault-mcp-tools --help' for usage information.");
+  } else if (err && err.code === "CONFIG_INVALID") {
+    console.error(`[vault-mcp] ${err.message}`);
+  } else {
+    console.error("[vault-mcp] Fatal error:", err);
+  }
+  process.exit(1);
+});