obsidian-native-mcp 0.2.0

package/dist/plugin/main.js

@@ -0,0 +1,1201 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugin/main.ts
+var main_exports = {};
+__export(main_exports, {
+  default: () => NativeMcpPlugin
+});
+module.exports = __toCommonJS(main_exports);
+var import_obsidian2 = require("obsidian");
+
+// src/mcp/http-transport.ts
+var import_http = __toESM(require("http"));
+var HttpTransport = class {
+  requestHandler = null;
+  server = null;
+  sessions = /* @__PURE__ */ new Map();
+  port = 0;
+  get url() {
+    return `http://127.0.0.1:${this.port}/sse`;
+  }
+  get actualPort() {
+    return this.port;
+  }
+  onRequest(handler) {
+    this.requestHandler = handler;
+  }
+  sendMessage(_message) {
+  }
+  start() {
+    return new Promise((resolve2) => {
+      this.server = import_http.default.createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+      this.server.listen(0, "127.0.0.1", () => {
+        const addr = this.server.address();
+        if (addr && typeof addr === "object") {
+          this.port = addr.port;
+        }
+        console.error(`MCP HTTP server listening on http://127.0.0.1:${this.port}`);
+        resolve2();
+      });
+    });
+  }
+  close() {
+    for (const res of this.sessions.values()) {
+      res.end();
+    }
+    this.sessions.clear();
+    this.server?.close();
+  }
+  handleRequest(req, res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    if (req.method === "GET" && url.pathname === "/sse") {
+      this.handleSSE(req, res);
+    } else if (req.method === "POST" && url.pathname === "/message") {
+      this.handleMessage(req, res);
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  }
+  handleSSE(req, res) {
+    const sessionId = generateId();
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    const messageUrl = `/message?session_id=${sessionId}`;
+    res.write(`event: endpoint
+data: ${messageUrl}
+
+`);
+    this.sessions.set(sessionId, res);
+    req.on("close", () => {
+      this.sessions.delete(sessionId);
+    });
+  }
+  handleMessage(req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const sessionId = url.searchParams.get("session_id");
+    if (!sessionId || !this.sessions.has(sessionId)) {
+      res.writeHead(400);
+      res.end("Invalid or missing session_id");
+      return;
+    }
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", async () => {
+      try {
+        const msg = JSON.parse(body);
+        if (msg.jsonrpc !== "2.0" || !("method" in msg) || !("id" in msg)) {
+          res.writeHead(400);
+          res.end("Invalid JSON-RPC message");
+          return;
+        }
+        const response = await this.requestHandler?.(msg);
+        if (response) {
+          const sseRes = this.sessions.get(sessionId);
+          if (sseRes) {
+            sseRes.write(`event: message
+data: ${JSON.stringify(response)}
+
+`);
+          }
+        }
+        res.writeHead(202);
+        res.end();
+      } catch {
+        res.writeHead(400);
+        res.end("Invalid JSON");
+      }
+    });
+  }
+};
+function generateId() {
+  return crypto.randomUUID();
+}
+
+// src/utils/fs-utils.ts
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+async function fileExists(path) {
+  try {
+    await (0, import_promises.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextFile(path) {
+  return (0, import_promises.readFile)(path, "utf-8");
+}
+async function writeTextFile(path, content) {
+  await (0, import_promises.writeFile)(path, content, "utf-8");
+}
+function listFiles(vaultPath, directory) {
+  const targetDir = directory ? (0, import_path.join)(vaultPath, directory) : vaultPath;
+  if (!(0, import_fs.existsSync)(targetDir)) {
+    throw new Error(`Directory not found: ${targetDir}`);
+  }
+  const entries = (0, import_fs.readdirSync)(targetDir);
+  const result = [];
+  for (const entry of entries) {
+    const fullPath = (0, import_path.join)(targetDir, entry);
+    const stat = (0, import_fs.statSync)(fullPath);
+    result.push({
+      name: entry,
+      path: (0, import_path.relative)(vaultPath, fullPath),
+      type: stat.isDirectory() ? "directory" : "file",
+      size: stat.size,
+      mtime: stat.mtime
+    });
+  }
+  return result.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+async function readFileHandler(vaultPath, filename) {
+  const fullPath = (0, import_path.join)(vaultPath, filename);
+  if (!await fileExists(fullPath)) {
+    throw new Error(`File not found: ${filename}`);
+  }
+  const stat = (0, import_fs.statSync)(fullPath);
+  if (!stat.isFile()) {
+    throw new Error(`Not a file: ${filename}`);
+  }
+  const content = await readTextFile(fullPath);
+  const parsed = parseFrontmatter(content);
+  return {
+    content,
+    frontmatter: parsed?.frontmatter
+  };
+}
+async function createFile(vaultPath, filename, content) {
+  const fullPath = (0, import_path.join)(vaultPath, filename);
+  const dir = (0, import_path.dirname)(fullPath);
+  if (!(0, import_fs.existsSync)(dir)) {
+    (0, import_fs.mkdirSync)(dir, { recursive: true });
+  }
+  await writeTextFile(fullPath, content);
+}
+async function appendFile(vaultPath, filename, content) {
+  const fullPath = (0, import_path.join)(vaultPath, filename);
+  const dir = (0, import_path.dirname)(fullPath);
+  if (!(0, import_fs.existsSync)(dir)) {
+    (0, import_fs.mkdirSync)(dir, { recursive: true });
+  }
+  let existing = "";
+  if (await fileExists(fullPath)) {
+    existing = await readTextFile(fullPath);
+  }
+  await writeTextFile(fullPath, existing + content);
+}
+function deleteFileHandler(vaultPath, filename) {
+  const fullPath = (0, import_path.join)(vaultPath, filename);
+  if (!(0, import_fs.existsSync)(fullPath)) {
+    throw new Error(`File not found: ${filename}`);
+  }
+  (0, import_fs.unlinkSync)(fullPath);
+}
+async function patchFile(vaultPath, filename, operation, targetType, target, content, options) {
+  const fullPath = (0, import_path.join)(vaultPath, filename);
+  if (!await fileExists(fullPath)) {
+    throw new Error(`File not found: ${filename}`);
+  }
+  const fileContent = await readTextFile(fullPath);
+  let modified;
+  if (targetType === "frontmatter") {
+    modified = patchFrontmatter(fileContent, operation, target, content);
+  } else if (targetType === "heading") {
+    modified = patchHeading(fileContent, operation, target, content, options);
+  } else if (targetType === "block") {
+    modified = patchBlock(fileContent, operation, target, content);
+  } else {
+    throw new Error(`Unsupported target type: ${targetType}`);
+  }
+  await writeTextFile(fullPath, modified);
+  return modified;
+}
+function parseFrontmatter(content) {
+  if (!content.startsWith("---")) return null;
+  const endIndex = content.indexOf("---", 3);
+  if (endIndex === -1) return null;
+  const raw = content.slice(3, endIndex).trim();
+  const body = content.slice(endIndex + 3).trim();
+  const frontmatter = {};
+  for (const line of raw.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      value = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+    }
+    frontmatter[key] = value;
+  }
+  return { frontmatter, body };
+}
+function patchFrontmatter(content, operation, target, newContent) {
+  const parsed = parseFrontmatter(content);
+  if (operation === "replace" && target === "all") {
+    if (parsed) {
+      return `---
+${newContent}
+---
+
+${parsed.body}`;
+    }
+    return `---
+${newContent}
+---
+
+${content}`;
+  }
+  if (parsed) {
+    const lines = content.split("\n");
+    let fmEnd = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trim() === "---") {
+        fmEnd = i;
+        break;
+      }
+    }
+    const fmLines = lines.slice(1, fmEnd);
+    const bodyLines = lines.slice(fmEnd + 1);
+    if (operation === "replace") {
+      const existing = fmLines.findIndex((l) => l.trim().startsWith(target + ":"));
+      if (existing !== -1) {
+        fmLines[existing] = `${target}: ${newContent}`;
+      } else {
+        fmLines.push(`${target}: ${newContent}`);
+      }
+    } else if (operation === "append") {
+      fmLines.push(`${target}: ${newContent}`);
+    }
+    return ["---", ...fmLines, "---", "", ...bodyLines].join("\n");
+  }
+  if (operation === "replace" || operation === "append") {
+    return `---
+${target}: ${newContent}
+---
+
+${content}`;
+  }
+  return content;
+}
+function findHeadingLine(lines, target, delimiter) {
+  const parts = target.split(delimiter).map((s) => s.trim());
+  let currentLine = 0;
+  for (const part of parts) {
+    let found = false;
+    for (let i = currentLine; i < lines.length; i++) {
+      const headingMatch = lines[i].match(/^(#{1,6})\s+(.+)$/);
+      if (headingMatch && headingMatch[2].trim() === part) {
+        currentLine = i;
+        found = true;
+        break;
+      }
+    }
+    if (!found) return null;
+  }
+  const match = lines[currentLine].match(/^(#{1,6})\s/);
+  return { lineIndex: currentLine, level: match ? match[1].length : 1 };
+}
+function getHeadingContentEnd(lines, startLine, level) {
+  for (let i = startLine + 1; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,6})\s/);
+    if (match && match[1].length <= level) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+function patchHeading(content, operation, target, newContent, options) {
+  const delimiter = options?.targetDelimiter || "::";
+  const lines = content.split("\n");
+  const heading = findHeadingLine(lines, target, delimiter);
+  if (!heading) {
+    if (operation === "replace") return content;
+    const targetParts = target.split(delimiter).map((s) => s.trim());
+    const lastPart = targetParts[targetParts.length - 1];
+    return content + `
+
+## ${lastPart}
+
+${newContent}`;
+  }
+  const sectionEnd = getHeadingContentEnd(lines, heading.lineIndex, heading.level);
+  if (operation === "replace") {
+    const newLines = [
+      ...lines.slice(0, heading.lineIndex + 1),
+      newContent,
+      ...lines.slice(sectionEnd)
+    ];
+    return newLines.join("\n");
+  }
+  if (operation === "append") {
+    const newLines = [...lines.slice(0, sectionEnd), newContent, ...lines.slice(sectionEnd)];
+    return newLines.join("\n");
+  }
+  if (operation === "prepend") {
+    const newLines = [
+      ...lines.slice(0, heading.lineIndex + 1),
+      newContent,
+      ...lines.slice(heading.lineIndex + 1)
+    ];
+    return newLines.join("\n");
+  }
+  return content;
+}
+function patchBlock(content, operation, target, newContent) {
+  const blockId = target.startsWith("^") ? target : `^${target}`;
+  const lines = content.split("\n");
+  const blockIndex = lines.findIndex((l) => l.trim().endsWith(blockId));
+  if (blockIndex === -1) {
+    if (operation === "replace") return content;
+    return content + `
+
+${newContent} ${blockId}`;
+  }
+  if (operation === "replace") {
+    lines[blockIndex] = lines[blockIndex].replace(/^(.*?)(\s+\^\w+)?$/, `${newContent} ${blockId}`);
+    return lines.join("\n");
+  }
+  if (operation === "append") {
+    lines.splice(blockIndex + 1, 0, newContent);
+    return lines.join("\n");
+  }
+  if (operation === "prepend") {
+    lines.splice(blockIndex, 0, newContent);
+    return lines.join("\n");
+  }
+  return content;
+}
+
+// src/utils/search.ts
+var import_fs2 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
+async function searchInVault(vaultPath, query, directory, contextLength = 100) {
+  const searchDir = directory ? (0, import_path2.join)(vaultPath, directory) : vaultPath;
+  const results = [];
+  const searchTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  await walkDir(searchDir, vaultPath, results, searchTerms, contextLength);
+  return results;
+}
+async function walkDir(dirPath, vaultPath, results, searchTerms, contextLength) {
+  let entries;
+  try {
+    entries = (0, import_fs2.readdirSync)(dirPath);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = (0, import_path2.join)(dirPath, entry);
+    let stat;
+    try {
+      stat = (0, import_fs2.statSync)(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      if (!entry.startsWith(".")) {
+        await walkDir(fullPath, vaultPath, results, searchTerms, contextLength);
+      }
+      continue;
+    }
+    if (!entry.endsWith(".md")) continue;
+    try {
+      const content = await (0, import_promises2.readFile)(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const relPath = (0, import_path2.relative)(vaultPath, fullPath);
+      for (let i = 0; i < lines.length; i++) {
+        const lowerLine = lines[i].toLowerCase();
+        const matchesAll = searchTerms.every((term) => lowerLine.includes(term));
+        if (matchesAll) {
+          results.push({
+            file: relPath,
+            line: i + 1,
+            content: lines[i].substring(0, 500),
+            contextBefore: i > 0 ? lines[i - 1].substring(0, contextLength) : void 0,
+            contextAfter: i < lines.length - 1 ? lines[i + 1].substring(0, contextLength) : void 0
+          });
+        }
+      }
+    } catch {
+    }
+  }
+}
+
+// src/handlers/tools.ts
+var VaultFileHandler = class {
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  getHandlers() {
+    return {
+      list_vaults: this.handleListVaults.bind(this),
+      get_vault_info: this.handleVaultInfo.bind(this),
+      list_files: this.handleListFiles.bind(this),
+      get_file: this.handleGetFile.bind(this),
+      create_file: this.handleCreateFile.bind(this),
+      append_to_file: this.handleAppendFile.bind(this),
+      patch_file: this.handlePatchFile.bind(this),
+      delete_file: this.handleDeleteFile.bind(this),
+      search: this.handleSearch.bind(this)
+    };
+  }
+  resolveVault(args) {
+    return this.registry.resolve(args.vault);
+  }
+  async handleListVaults(_args) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(this.registry.list(), null, 2)
+        }
+      ]
+    };
+  }
+  async handleVaultInfo(args) {
+    const info = this.registry.info(args.vault);
+    return {
+      content: [{ type: "text", text: JSON.stringify(info, null, 2) }]
+    };
+  }
+  async handleListFiles(args) {
+    const vaultPath = this.resolveVault(args);
+    const entries = listFiles(vaultPath, args.directory);
+    return {
+      content: [{ type: "text", text: JSON.stringify(entries, null, 2) }]
+    };
+  }
+  async handleGetFile(args) {
+    const vaultPath = this.resolveVault(args);
+    const result = await readFileHandler(vaultPath, args.filename);
+    if (args.format === "json") {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                filename: args.filename,
+                frontmatter: result.frontmatter,
+                content: result.content
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    return { content: [{ type: "text", text: result.content }] };
+  }
+  async handleCreateFile(args) {
+    const vaultPath = this.resolveVault(args);
+    await createFile(vaultPath, args.filename, args.content);
+    return {
+      content: [{ type: "text", text: "File created successfully" }]
+    };
+  }
+  async handleAppendFile(args) {
+    const vaultPath = this.resolveVault(args);
+    await appendFile(vaultPath, args.filename, args.content);
+    return {
+      content: [{ type: "text", text: "Content appended successfully" }]
+    };
+  }
+  async handlePatchFile(args) {
+    const vaultPath = this.resolveVault(args);
+    const result = await patchFile(
+      vaultPath,
+      args.filename,
+      args.operation,
+      args.targetType,
+      args.target,
+      args.content,
+      {
+        contentType: args.contentType,
+        targetDelimiter: args.targetDelimiter,
+        trimTargetWhitespace: args.trimTargetWhitespace
+      }
+    );
+    return {
+      content: [
+        { type: "text", text: "File patched successfully" },
+        { type: "text", text: result }
+      ]
+    };
+  }
+  async handleDeleteFile(args) {
+    const vaultPath = this.resolveVault(args);
+    deleteFileHandler(vaultPath, args.filename);
+    return {
+      content: [{ type: "text", text: "File deleted successfully" }]
+    };
+  }
+  async handleSearch(args) {
+    const vaultPath = this.resolveVault(args);
+    const matches = await searchInVault(vaultPath, args.query, args.directory, args.contextLength);
+    return {
+      content: [{ type: "text", text: JSON.stringify(matches, null, 2) }]
+    };
+  }
+};
+
+// src/handlers/prompts.ts
+var import_fs3 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_path3 = require("path");
+function parseFrontmatter2(content) {
+  if (!content.startsWith("---")) return null;
+  const endIndex = content.indexOf("---", 3);
+  if (endIndex === -1) return null;
+  const raw = content.slice(3, endIndex).trim();
+  const body = content.slice(endIndex + 3).trim();
+  const frontmatter = {};
+  for (const line of raw.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+    else if (value.startsWith("[") && value.endsWith("]")) {
+      value = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+    }
+    frontmatter[key] = value;
+  }
+  return { frontmatter, body };
+}
+var PromptHandler = class {
+  registry;
+  promptDir = "Prompts";
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async list(vaultName) {
+    const vaultPath = this.registry.resolve(vaultName);
+    const promptPath = (0, import_path3.join)(vaultPath, this.promptDir);
+    let entries;
+    try {
+      entries = (0, import_fs3.readdirSync)(promptPath);
+    } catch {
+      return [];
+    }
+    const prompts = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const fullPath = (0, import_path3.join)(promptPath, entry);
+      const stat = (0, import_fs3.statSync)(fullPath);
+      if (!stat.isFile()) continue;
+      try {
+        const content = await (0, import_promises3.readFile)(fullPath, "utf-8");
+        const parsed = parseFrontmatter2(content);
+        const tags = parsed?.frontmatter?.tags || [];
+        if (!tags.includes("mcp-tools-prompt")) continue;
+        const promptArgs = parsePromptParameters(parsed?.body || content);
+        prompts.push({
+          name: entry,
+          description: parsed?.frontmatter?.description || entry.replace(".md", ""),
+          arguments: promptArgs
+        });
+      } catch {
+        continue;
+      }
+    }
+    return prompts;
+  }
+  async get(name, vaultName) {
+    const vaultPath = this.registry.resolve(vaultName);
+    const promptPath = (0, import_path3.join)(vaultPath, this.promptDir, name);
+    let content;
+    try {
+      content = await (0, import_promises3.readFile)(promptPath, "utf-8");
+    } catch {
+      throw new Error(`Prompt not found: ${name}`);
+    }
+    const parsed = parseFrontmatter2(content);
+    const body = parsed?.body || content;
+    const withoutFrontmatter = body.trim();
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: withoutFrontmatter
+          }
+        }
+      ]
+    };
+  }
+};
+function parsePromptParameters(content) {
+  const regex = /<%[-_*]*\s*tp\.mcpTools\.prompt\(([^)]+)\)\s*[-_]*%>/g;
+  const params = [];
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    try {
+      const argsStr = match[1];
+      const args = argsStr.split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      if (args.length >= 1) {
+        params.push({
+          name: args[0],
+          description: args[1],
+          required: true
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return params;
+}
+
+// src/mcp/server.ts
+var vaultParam = {
+  vault: {
+    type: "string",
+    description: "Vault name (derived from the directory name). Required when multiple vaults are configured."
+  }
+};
+function createServer(registry) {
+  const vaultList = registry.list();
+  const vaultNames = vaultList.map((v) => v.name);
+  vaultParam.vault.description = `Vault name. Available: ${vaultNames.join(", ")}`;
+  const fileHandler = new VaultFileHandler(registry);
+  const promptHandler = new PromptHandler(registry);
+  const toolHandlers = fileHandler.getHandlers();
+  const toolDefinitions = [
+    {
+      name: "list_vaults",
+      description: "List all configured vaults with their paths.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "get_vault_info",
+      description: "Get stats for a vault (file count, path, name).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          vault: {
+            type: "string",
+            description: `Vault name. Available: ${vaultNames.join(", ")}`
+          }
+        }
+      }
+    },
+    {
+      name: "list_files",
+      description: "List files in the root directory or a specified subdirectory of your vault.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          directory: {
+            type: "string",
+            description: "Optional subdirectory path relative to vault root"
+          }
+        }
+      }
+    },
+    {
+      name: "get_file",
+      description: "Get the content of a file from your vault.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: {
+            type: "string",
+            description: "Path to the file relative to vault root"
+          },
+          format: {
+            type: "string",
+            enum: ["markdown", "json"],
+            description: "Return format (json includes frontmatter)"
+          }
+        },
+        required: ["filename"]
+      }
+    },
+    {
+      name: "create_file",
+      description: "Create a new file in your vault or update an existing one.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: {
+            type: "string",
+            description: "Path to the file relative to vault root"
+          },
+          content: { type: "string", description: "File content" }
+        },
+        required: ["filename", "content"]
+      }
+    },
+    {
+      name: "append_to_file",
+      description: "Append content to a new or existing file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: {
+            type: "string",
+            description: "Path to the file relative to vault root"
+          },
+          content: {
+            type: "string",
+            description: "Content to append"
+          }
+        },
+        required: ["filename", "content"]
+      }
+    },
+    {
+      name: "patch_file",
+      description: "Insert or modify content in a file relative to a heading, block reference, or frontmatter field.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: { type: "string" },
+          operation: {
+            type: "string",
+            enum: ["append", "prepend", "replace"]
+          },
+          targetType: {
+            type: "string",
+            enum: ["heading", "block", "frontmatter"]
+          },
+          target: { type: "string" },
+          content: { type: "string" },
+          contentType: {
+            type: "string",
+            enum: ["text/markdown", "application/json"]
+          },
+          targetDelimiter: { type: "string", default: "::" },
+          trimTargetWhitespace: { type: "boolean", default: true }
+        },
+        required: ["filename", "operation", "targetType", "target", "content"]
+      }
+    },
+    {
+      name: "delete_file",
+      description: "Delete a file from your vault.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: {
+            type: "string",
+            description: "Path to the file relative to vault root"
+          }
+        },
+        required: ["filename"]
+      }
+    },
+    {
+      name: "search",
+      description: "Search for documents matching a text query in your vault.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          query: { type: "string", description: "Text to search for" },
+          directory: {
+            type: "string",
+            description: "Optional directory to scope the search"
+          },
+          contextLength: {
+            type: "number",
+            description: "Characters of context around each match"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  ];
+  async function handleRequest(msg) {
+    const { method, params, id } = msg;
+    switch (method) {
+      case "initialize": {
+        const clientProtocol = params?.protocolVersion;
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: clientProtocol || "2024-11-05",
+            capabilities: { tools: {}, prompts: {} },
+            serverInfo: { name: "obsidian-native-mcp", version: "0.2.0" }
+          }
+        };
+      }
+      case "tools/list":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: { tools: toolDefinitions }
+        };
+      case "tools/call": {
+        const toolName = params?.name;
+        const args = params?.arguments || {};
+        const handler = toolHandlers[toolName];
+        if (!handler) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32601, message: `Unknown tool: ${toolName}` }
+          };
+        }
+        try {
+          const result = await handler(args);
+          return { jsonrpc: "2.0", id, result };
+        } catch (err) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32603, message: err.message || String(err) }
+          };
+        }
+      }
+      case "prompts/list": {
+        try {
+          const promptVault = params?.arguments?.vault;
+          const promptList = await promptHandler.list(promptVault);
+          return { jsonrpc: "2.0", id, result: { prompts: promptList } };
+        } catch (err) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32603, message: err.message || String(err) }
+          };
+        }
+      }
+      case "prompts/get": {
+        try {
+          const promptVault = params?.arguments?.vault;
+          const result = await promptHandler.get(params?.name, promptVault);
+          return { jsonrpc: "2.0", id, result };
+        } catch (err) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32603, message: err.message || String(err) }
+          };
+        }
+      }
+      case "notifications/initialized":
+      case "notifications/cancelled":
+      case "notifications/roots/list_changed":
+        return null;
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32601, message: `Method not found: ${method}` }
+        };
+    }
+  }
+  return { toolDefinitions, handleRequest };
+}
+
+// src/utils/vaults.ts
+var import_os = require("os");
+var import_path4 = require("path");
+var import_fs4 = require("fs");
+var IS_WIN = (0, import_os.platform)() === "win32";
+var VaultRegistry = class {
+  vaults = /* @__PURE__ */ new Map();
+  constructor() {
+    const fromEnv = this.parseEnv();
+    const fromConfig = this.parseConfigFile();
+    if (fromEnv.length > 0) {
+      for (const v of fromEnv) this.vaults.set(v.name, v.path);
+    } else if (fromConfig.length > 0) {
+      for (const v of fromConfig) this.vaults.set(v.name, v.path);
+    }
+  }
+  configure(vaults) {
+    this.vaults.clear();
+    for (const v of vaults) {
+      this.vaults.set(v.name, v.path);
+    }
+  }
+  static discoverFromObsidian() {
+    const configPath = obsidianConfigPath();
+    if (!configPath || !(0, import_fs4.existsSync)(configPath)) return [];
+    try {
+      const raw = (0, import_fs4.readFileSync)(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      const vaults = config.vaults;
+      if (!vaults) return [];
+      return Object.entries(vaults).filter(([, v]) => v && typeof v.path === "string").map(([name, v]) => ({
+        name,
+        path: (0, import_path4.resolve)(v.path.replace(/^~/, (0, import_os.homedir)()))
+      }));
+    } catch {
+      return [];
+    }
+  }
+  resolve(name) {
+    if (name) {
+      const path = this.vaults.get(name);
+      if (!path) {
+        const available2 = this.list().map((v) => v.name).join(", ");
+        throw new Error(`Unknown vault "${name}". Available vaults: ${available2}`);
+      }
+      return path;
+    }
+    if (this.vaults.size === 1) {
+      return this.vaults.values().next().value;
+    }
+    const available = this.list().map((v) => v.name).join(", ");
+    throw new Error(`Multiple vaults configured but no vault specified. Choose one: ${available}`);
+  }
+  list() {
+    return Array.from(this.vaults.entries()).map(([name, path]) => ({
+      name,
+      path
+    }));
+  }
+  info(name) {
+    const vaultPath = this.resolve(name);
+    let fileCount = 0;
+    try {
+      const walkDir2 = (dir) => {
+        for (const entry of (0, import_fs4.readdirSync)(dir)) {
+          const full = (0, import_path4.join)(dir, entry);
+          try {
+            const stat = (0, import_fs4.statSync)(full);
+            if (stat.isDirectory()) {
+              if (!entry.startsWith(".")) walkDir2(full);
+            } else if (entry.endsWith(".md")) {
+              fileCount++;
+            }
+          } catch {
+          }
+        }
+      };
+      walkDir2(vaultPath);
+    } catch {
+    }
+    return { name: (0, import_path4.basename)(vaultPath), path: vaultPath, fileCount };
+  }
+  parseEnv() {
+    const envVal = process.env.OBSIDIAN_VAULT_PATHS;
+    if (!envVal) return [];
+    const separator = /[;\n]/;
+    const parts = envVal.split(separator).map((s) => s.trim()).filter(Boolean);
+    return parts.map((p) => {
+      const resolved = (0, import_path4.resolve)(p.replace(/^~/, (0, import_os.homedir)()));
+      return { name: (0, import_path4.basename)(resolved), path: resolved };
+    });
+  }
+  configDir() {
+    if (IS_WIN) {
+      return (0, import_path4.resolve)(
+        process.env.APPDATA || (0, import_path4.join)((0, import_os.homedir)(), "AppData", "Roaming"),
+        "obsidian-native-mcp"
+      );
+    }
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg) return (0, import_path4.resolve)(xdg, "obsidian-native-mcp");
+    return (0, import_path4.resolve)((0, import_os.homedir)(), ".config", "obsidian-native-mcp");
+  }
+  parseConfigFile() {
+    const configPath = (0, import_path4.join)(this.configDir(), "vaults.json");
+    if (!(0, import_fs4.existsSync)(configPath)) return [];
+    try {
+      const raw = (0, import_fs4.readFileSync)(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      const resolved = [];
+      const entries = config.vaults ? Object.entries(config.vaults) : Object.entries(config).filter(([k]) => k !== "default");
+      for (const [name, path] of entries) {
+        if (typeof path === "string") {
+          resolved.push({ name, path: (0, import_path4.resolve)(path.replace(/^~/, (0, import_os.homedir)())) });
+        }
+      }
+      return resolved;
+    } catch {
+      return [];
+    }
+  }
+};
+function obsidianConfigPath() {
+  if (IS_WIN) {
+    const appData = process.env.APPDATA;
+    if (!appData) return null;
+    return (0, import_path4.resolve)(appData, "obsidian", "obsidian.json");
+  }
+  if ((0, import_os.platform)() === "darwin") {
+    return (0, import_path4.resolve)((0, import_os.homedir)(), "Library", "Application Support", "obsidian", "obsidian.json");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return (0, import_path4.resolve)(xdg, "obsidian", "obsidian.json");
+  return (0, import_path4.resolve)((0, import_os.homedir)(), ".config", "obsidian", "obsidian.json");
+}
+
+// src/plugin/settings.ts
+var import_obsidian = require("obsidian");
+var NativeMcpSettingTab = class extends import_obsidian.PluginSettingTab {
+  plugin;
+  constructor(app, plugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+  display() {
+    const { containerEl } = this;
+    containerEl.empty();
+    containerEl.createEl("h2", { text: "Obsidian Native MCP" });
+    const url = this.plugin.getServerUrl();
+    if (url) {
+      new import_obsidian.Setting(containerEl).setName("MCP Server URL").setDesc("Add this URL to your Claude Desktop config").addText((text) => {
+        text.setValue(url).setDisabled(true);
+        text.inputEl.style.width = "100%";
+      }).addButton((btn) => {
+        btn.setButtonText("Copy").onClick(async () => {
+          await navigator.clipboard.writeText(url);
+          btn.setButtonText("Copied!");
+          setTimeout(() => btn.setButtonText("Copy"), 2e3);
+        });
+      });
+    } else {
+      new import_obsidian.Setting(containerEl).setName("Server inactive").setDesc("Select at least one vault below to start the MCP server.");
+    }
+    containerEl.createEl("h3", { text: "Vaults" });
+    const allVaults = VaultRegistry.discoverFromObsidian();
+    const selected = this.plugin.getSettings().selectedVaults;
+    if (allVaults.length === 0) {
+      containerEl.createEl("p", {
+        text: "No Obsidian vaults found. Make sure Obsidian has been started at least once."
+      });
+      return;
+    }
+    for (const vault of allVaults) {
+      const isSelected = selected.includes(vault.name);
+      new import_obsidian.Setting(containerEl).setName(vault.name).setDesc(vault.path).addToggle(
+        (toggle) => toggle.setValue(isSelected).onChange(async (value) => {
+          const newSelected = value ? [...selected, vault.name] : selected.filter((n) => n !== vault.name);
+          await this.plugin.updateSelectedVaults(newSelected);
+          this.display();
+        })
+      );
+    }
+  }
+};
+
+// src/plugin/main.ts
+var DEFAULT_SETTINGS = {
+  selectedVaults: []
+};
+var NativeMcpPlugin = class extends import_obsidian2.Plugin {
+  transport = null;
+  settings = DEFAULT_SETTINGS;
+  registry = new VaultRegistry();
+  async onload() {
+    await this.loadSettings();
+    const allVaults = VaultRegistry.discoverFromObsidian();
+    if (this.settings.selectedVaults.length > 0) {
+      const selected = allVaults.filter((v) => this.settings.selectedVaults.includes(v.name));
+      if (selected.length > 0) {
+        this.registry.configure(selected);
+      }
+    }
+    if (this.registry.list().length > 0) {
+      await this.startServer();
+    }
+    this.addSettingTab(new NativeMcpSettingTab(this.app, this));
+  }
+  async startServer() {
+    this.transport?.close();
+    const server = createServer(this.registry);
+    this.transport = new HttpTransport();
+    this.transport.onRequest(async (msg) => server.handleRequest(msg));
+    await this.transport.start();
+  }
+  restartServer() {
+    this.startServer();
+  }
+  getServerUrl() {
+    return this.transport?.url ?? null;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+  async loadSettings() {
+    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+  }
+  async saveSettings() {
+    await this.saveData(this.settings);
+  }
+  getSettings() {
+    return this.settings;
+  }
+  async updateSelectedVaults(names) {
+    this.settings.selectedVaults = names;
+    await this.saveSettings();
+    const allVaults = VaultRegistry.discoverFromObsidian();
+    const selected = allVaults.filter((v) => names.includes(v.name));
+    this.registry.configure(selected);
+    if (selected.length > 0) {
+      await this.startServer();
+    } else {
+      this.transport?.close();
+      this.transport = null;
+    }
+  }
+  onunload() {
+    this.transport?.close();
+  }
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/plugin/main.ts", "../../src/mcp/http-transport.ts", "../../src/utils/fs-utils.ts", "../../src/utils/search.ts", "../../src/handlers/tools.ts", "../../src/handlers/prompts.ts", "../../src/mcp/server.ts", "../../src/utils/vaults.ts", "../../src/plugin/settings.ts"],
  "sourcesContent": ["import { Plugin } from \"obsidian\";\nimport { HttpTransport } from \"../mcp/http-transport\";\nimport { createServer } from \"../mcp/server\";\nimport { VaultRegistry } from \"../utils/vaults\";\nimport { NativeMcpSettingTab } from \"./settings\";\n\ninterface PluginSettings {\n  selectedVaults: string[];\n}\n\nconst DEFAULT_SETTINGS: PluginSettings = {\n  selectedVaults: [],\n};\n\nexport default class NativeMcpPlugin extends Plugin {\n  private transport: HttpTransport | null = null;\n  private settings: PluginSettings = DEFAULT_SETTINGS;\n  private registry = new VaultRegistry();\n\n  async onload(): Promise<void> {\n    await this.loadSettings();\n\n    const allVaults = VaultRegistry.discoverFromObsidian();\n\n    if (this.settings.selectedVaults.length > 0) {\n      const selected = allVaults.filter((v) => this.settings.selectedVaults.includes(v.name));\n      if (selected.length > 0) {\n        this.registry.configure(selected);\n      }\n    }\n\n    if (this.registry.list().length > 0) {\n      await this.startServer();\n    }\n\n    this.addSettingTab(new NativeMcpSettingTab(this.app, this));\n  }\n\n  async startServer(): Promise<void> {\n    this.transport?.close();\n\n    const server = createServer(this.registry);\n    this.transport = new HttpTransport();\n    this.transport.onRequest(async (msg) => server.handleRequest(msg));\n    await this.transport.start();\n  }\n\n  restartServer(): void {\n    this.startServer();\n  }\n\n  getServerUrl(): string | null {\n    return this.transport?.url ?? null;\n  }\n\n  getRegistry(): VaultRegistry {\n    return this.registry;\n  }\n\n  async loadSettings(): Promise<void> {\n    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n  }\n\n  async saveSettings(): Promise<void> {\n    await this.saveData(this.settings);\n  }\n\n  getSettings(): PluginSettings {\n    return this.settings;\n  }\n\n  async updateSelectedVaults(names: string[]): Promise<void> {\n    this.settings.selectedVaults = names;\n    await this.saveSettings();\n\n    const allVaults = VaultRegistry.discoverFromObsidian();\n    const selected = allVaults.filter((v) => names.includes(v.name));\n    this.registry.configure(selected);\n\n    if (selected.length > 0) {\n      await this.startServer();\n    } else {\n      this.transport?.close();\n      this.transport = null;\n    }\n  }\n\n  onunload(): void {\n    this.transport?.close();\n  }\n}\n", "import http from \"http\";\nimport type { JSONRPCRequest, JSONRPCResponse } from \"./protocol\";\n\nexport class HttpTransport {\n  private requestHandler: ((request: JSONRPCRequest) => Promise<JSONRPCResponse | null>) | null =\n    null;\n  private server: http.Server | null = null;\n  private sessions = new Map<string, http.ServerResponse>();\n  private port = 0;\n\n  get url(): string {\n    return `http://127.0.0.1:${this.port}/sse`;\n  }\n\n  get actualPort(): number {\n    return this.port;\n  }\n\n  onRequest(handler: (request: JSONRPCRequest) => Promise<JSONRPCResponse | null>): void {\n    this.requestHandler = handler;\n  }\n\n  sendMessage(_message: JSONRPCResponse): void {\n    // Messages sent back via SSE response, not directly\n  }\n\n  start(): Promise<void> {\n    return new Promise((resolve) => {\n      this.server = http.createServer((req, res) => {\n        this.handleRequest(req, res);\n      });\n\n      this.server.listen(0, \"127.0.0.1\", () => {\n        const addr = this.server!.address();\n        if (addr && typeof addr === \"object\") {\n          this.port = addr.port;\n        }\n        console.error(`MCP HTTP server listening on http://127.0.0.1:${this.port}`);\n        resolve();\n      });\n    });\n  }\n\n  close(): void {\n    for (const res of this.sessions.values()) {\n      res.end();\n    }\n    this.sessions.clear();\n    this.server?.close();\n  }\n\n  private handleRequest(req: http.IncomingMessage, res: http.ServerResponse): void {\n    // CORS headers for Claude Desktop\n    res.setHeader(\"Access-Control-Allow-Origin\", \"*\");\n    res.setHeader(\"Access-Control-Allow-Methods\", \"GET, POST, OPTIONS\");\n    res.setHeader(\"Access-Control-Allow-Headers\", \"Content-Type\");\n\n    if (req.method === \"OPTIONS\") {\n      res.writeHead(204);\n      res.end();\n      return;\n    }\n\n    const url = new URL(req.url || \"/\", `http://${req.headers.host || \"localhost\"}`);\n\n    if (req.method === \"GET\" && url.pathname === \"/sse\") {\n      this.handleSSE(req, res);\n    } else if (req.method === \"POST\" && url.pathname === \"/message\") {\n      this.handleMessage(req, res);\n    } else {\n      res.writeHead(404);\n      res.end(\"Not found\");\n    }\n  }\n\n  private handleSSE(req: http.IncomingMessage, res: http.ServerResponse): void {\n    const sessionId = generateId();\n\n    res.writeHead(200, {\n      \"Content-Type\": \"text/event-stream\",\n      \"Cache-Control\": \"no-cache\",\n      Connection: \"keep-alive\",\n    });\n\n    const messageUrl = `/message?session_id=${sessionId}`;\n    res.write(`event: endpoint\\ndata: ${messageUrl}\\n\\n`);\n\n    this.sessions.set(sessionId, res);\n\n    req.on(\"close\", () => {\n      this.sessions.delete(sessionId);\n    });\n  }\n\n  private handleMessage(req: http.IncomingMessage, res: http.ServerResponse): void {\n    const url = new URL(req.url || \"/\", `http://${req.headers.host || \"localhost\"}`);\n    const sessionId = url.searchParams.get(\"session_id\");\n\n    if (!sessionId || !this.sessions.has(sessionId)) {\n      res.writeHead(400);\n      res.end(\"Invalid or missing session_id\");\n      return;\n    }\n\n    let body = \"\";\n    req.on(\"data\", (chunk: Buffer) => {\n      body += chunk.toString();\n    });\n    req.on(\"end\", async () => {\n      try {\n        const msg = JSON.parse(body);\n        if (msg.jsonrpc !== \"2.0\" || !(\"method\" in msg) || !(\"id\" in msg)) {\n          res.writeHead(400);\n          res.end(\"Invalid JSON-RPC message\");\n          return;\n        }\n\n        const response = await this.requestHandler?.(msg as JSONRPCRequest);\n        if (response) {\n          const sseRes = this.sessions.get(sessionId);\n          if (sseRes) {\n            sseRes.write(`event: message\\ndata: ${JSON.stringify(response)}\\n\\n`);\n          }\n        }\n\n        res.writeHead(202);\n        res.end();\n      } catch {\n        res.writeHead(400);\n        res.end(\"Invalid JSON\");\n      }\n    });\n  }\n}\n\nfunction generateId(): string {\n  return crypto.randomUUID();\n}\n", "import { readdirSync, statSync, unlinkSync, mkdirSync, existsSync } from \"fs\";\nimport { readFile, writeFile, access } from \"fs/promises\";\nimport { join, dirname, relative } from \"path\";\n\nexport interface FileEntry {\n  name: string;\n  path: string;\n  type: \"file\" | \"directory\";\n  size?: number;\n  mtime?: Date;\n}\n\nasync function fileExists(path: string): Promise<boolean> {\n  try {\n    await access(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function readTextFile(path: string): Promise<string> {\n  return readFile(path, \"utf-8\");\n}\n\nasync function writeTextFile(path: string, content: string): Promise<void> {\n  await writeFile(path, content, \"utf-8\");\n}\n\nexport function listFiles(vaultPath: string, directory?: string): FileEntry[] {\n  const targetDir = directory ? join(vaultPath, directory) : vaultPath;\n\n  if (!existsSync(targetDir)) {\n    throw new Error(`Directory not found: ${targetDir}`);\n  }\n\n  const entries = readdirSync(targetDir);\n  const result: FileEntry[] = [];\n\n  for (const entry of entries) {\n    const fullPath = join(targetDir, entry);\n    const stat = statSync(fullPath);\n    result.push({\n      name: entry,\n      path: relative(vaultPath, fullPath),\n      type: stat.isDirectory() ? \"directory\" : \"file\",\n      size: stat.size,\n      mtime: stat.mtime,\n    });\n  }\n\n  return result.sort((a, b) => {\n    if (a.type !== b.type) return a.type === \"directory\" ? -1 : 1;\n    return a.name.localeCompare(b.name);\n  });\n}\n\nexport async function readFileHandler(\n  vaultPath: string,\n  filename: string,\n): Promise<{ content: string; frontmatter?: Record<string, any> }> {\n  const fullPath = join(vaultPath, filename);\n\n  if (!(await fileExists(fullPath))) {\n    throw new Error(`File not found: ${filename}`);\n  }\n\n  const stat = statSync(fullPath);\n  if (!stat.isFile()) {\n    throw new Error(`Not a file: ${filename}`);\n  }\n\n  const content = await readTextFile(fullPath);\n  const parsed = parseFrontmatter(content);\n\n  return {\n    content,\n    frontmatter: parsed?.frontmatter,\n  };\n}\n\nexport async function createFile(\n  vaultPath: string,\n  filename: string,\n  content: string,\n): Promise<void> {\n  const fullPath = join(vaultPath, filename);\n  const dir = dirname(fullPath);\n\n  if (!existsSync(dir)) {\n    mkdirSync(dir, { recursive: true });\n  }\n\n  await writeTextFile(fullPath, content);\n}\n\nexport async function appendFile(\n  vaultPath: string,\n  filename: string,\n  content: string,\n): Promise<void> {\n  const fullPath = join(vaultPath, filename);\n  const dir = dirname(fullPath);\n\n  if (!existsSync(dir)) {\n    mkdirSync(dir, { recursive: true });\n  }\n\n  let existing = \"\";\n  if (await fileExists(fullPath)) {\n    existing = await readTextFile(fullPath);\n  }\n\n  await writeTextFile(fullPath, existing + content);\n}\n\nexport function deleteFileHandler(vaultPath: string, filename: string): void {\n  const fullPath = join(vaultPath, filename);\n\n  if (!existsSync(fullPath)) {\n    throw new Error(`File not found: ${filename}`);\n  }\n\n  unlinkSync(fullPath);\n}\n\nexport async function patchFile(\n  vaultPath: string,\n  filename: string,\n  operation: \"append\" | \"prepend\" | \"replace\",\n  targetType: \"heading\" | \"block\" | \"frontmatter\",\n  target: string,\n  content: string,\n  options?: {\n    contentType?: string;\n    targetDelimiter?: string;\n    trimTargetWhitespace?: boolean;\n  },\n): Promise<string> {\n  const fullPath = join(vaultPath, filename);\n\n  if (!(await fileExists(fullPath))) {\n    throw new Error(`File not found: ${filename}`);\n  }\n\n  const fileContent = await readTextFile(fullPath);\n  let modified: string;\n\n  if (targetType === \"frontmatter\") {\n    modified = patchFrontmatter(fileContent, operation, target, content);\n  } else if (targetType === \"heading\") {\n    modified = patchHeading(fileContent, operation, target, content, options);\n  } else if (targetType === \"block\") {\n    modified = patchBlock(fileContent, operation, target, content);\n  } else {\n    throw new Error(`Unsupported target type: ${targetType}`);\n  }\n\n  await writeTextFile(fullPath, modified);\n  return modified;\n}\n\nfunction parseFrontmatter(\n  content: string,\n): { frontmatter: Record<string, any>; body: string } | null {\n  if (!content.startsWith(\"---\")) return null;\n\n  const endIndex = content.indexOf(\"---\", 3);\n  if (endIndex === -1) return null;\n\n  const raw = content.slice(3, endIndex).trim();\n  const body = content.slice(endIndex + 3).trim();\n  const frontmatter: Record<string, any> = {};\n\n  for (const line of raw.split(\"\\n\")) {\n    const colonIndex = line.indexOf(\":\");\n    if (colonIndex === -1) continue;\n    const key = line.slice(0, colonIndex).trim();\n    let value: any = line.slice(colonIndex + 1).trim();\n\n    if (value.startsWith('\"') && value.endsWith('\"')) {\n      value = value.slice(1, -1);\n    } else if (value.startsWith(\"[\") && value.endsWith(\"]\")) {\n      value = value\n        .slice(1, -1)\n        .split(\",\")\n        .map((s: string) => s.trim().replace(/^[\"']|[\"']$/g, \"\"))\n        .filter(Boolean);\n    }\n\n    frontmatter[key] = value;\n  }\n\n  return { frontmatter, body };\n}\n\nfunction patchFrontmatter(\n  content: string,\n  operation: \"append\" | \"prepend\" | \"replace\",\n  target: string,\n  newContent: string,\n): string {\n  const parsed = parseFrontmatter(content);\n\n  if (operation === \"replace\" && target === \"all\") {\n    if (parsed) {\n      return `---\\n${newContent}\\n---\\n\\n${parsed.body}`;\n    }\n    return `---\\n${newContent}\\n---\\n\\n${content}`;\n  }\n\n  if (parsed) {\n    const lines = content.split(\"\\n\");\n    let fmEnd = -1;\n    for (let i = 1; i < lines.length; i++) {\n      if (lines[i].trim() === \"---\") {\n        fmEnd = i;\n        break;\n      }\n    }\n\n    const fmLines = lines.slice(1, fmEnd);\n    const bodyLines = lines.slice(fmEnd + 1);\n\n    if (operation === \"replace\") {\n      const existing = fmLines.findIndex((l) => l.trim().startsWith(target + \":\"));\n      if (existing !== -1) {\n        fmLines[existing] = `${target}: ${newContent}`;\n      } else {\n        fmLines.push(`${target}: ${newContent}`);\n      }\n    } else if (operation === \"append\") {\n      fmLines.push(`${target}: ${newContent}`);\n    }\n\n    return [\"---\", ...fmLines, \"---\", \"\", ...bodyLines].join(\"\\n\");\n  }\n\n  if (operation === \"replace\" || operation === \"append\") {\n    return `---\\n${target}: ${newContent}\\n---\\n\\n${content}`;\n  }\n\n  return content;\n}\n\nfunction findHeadingLine(\n  lines: string[],\n  target: string,\n  delimiter: string,\n): { lineIndex: number; level: number } | null {\n  const parts = target.split(delimiter).map((s) => s.trim());\n\n  let currentLine = 0;\n  for (const part of parts) {\n    let found = false;\n    for (let i = currentLine; i < lines.length; i++) {\n      const headingMatch = lines[i].match(/^(#{1,6})\\s+(.+)$/);\n      if (headingMatch && headingMatch[2].trim() === part) {\n        currentLine = i;\n        found = true;\n        break;\n      }\n    }\n    if (!found) return null;\n  }\n\n  const match = lines[currentLine].match(/^(#{1,6})\\s/);\n  return { lineIndex: currentLine, level: match ? match[1].length : 1 };\n}\n\nfunction getHeadingContentEnd(lines: string[], startLine: number, level: number): number {\n  for (let i = startLine + 1; i < lines.length; i++) {\n    const match = lines[i].match(/^(#{1,6})\\s/);\n    if (match && match[1].length <= level) {\n      return i;\n    }\n  }\n  return lines.length;\n}\n\nfunction patchHeading(\n  content: string,\n  operation: \"append\" | \"prepend\" | \"replace\",\n  target: string,\n  newContent: string,\n  options?: any,\n): string {\n  const delimiter = options?.targetDelimiter || \"::\";\n  const lines = content.split(\"\\n\");\n  const heading = findHeadingLine(lines, target, delimiter);\n\n  if (!heading) {\n    if (operation === \"replace\") return content;\n    const targetParts = target.split(delimiter).map((s) => s.trim());\n    const lastPart = targetParts[targetParts.length - 1];\n    return content + `\\n\\n## ${lastPart}\\n\\n${newContent}`;\n  }\n\n  const sectionEnd = getHeadingContentEnd(lines, heading.lineIndex, heading.level);\n\n  if (operation === \"replace\") {\n    const newLines = [\n      ...lines.slice(0, heading.lineIndex + 1),\n      newContent,\n      ...lines.slice(sectionEnd),\n    ];\n    return newLines.join(\"\\n\");\n  }\n\n  if (operation === \"append\") {\n    const newLines = [...lines.slice(0, sectionEnd), newContent, ...lines.slice(sectionEnd)];\n    return newLines.join(\"\\n\");\n  }\n\n  if (operation === \"prepend\") {\n    const newLines = [\n      ...lines.slice(0, heading.lineIndex + 1),\n      newContent,\n      ...lines.slice(heading.lineIndex + 1),\n    ];\n    return newLines.join(\"\\n\");\n  }\n\n  return content;\n}\n\nfunction patchBlock(\n  content: string,\n  operation: \"append\" | \"prepend\" | \"replace\",\n  target: string,\n  newContent: string,\n): string {\n  const blockId = target.startsWith(\"^\") ? target : `^${target}`;\n  const lines = content.split(\"\\n\");\n  const blockIndex = lines.findIndex((l) => l.trim().endsWith(blockId));\n\n  if (blockIndex === -1) {\n    if (operation === \"replace\") return content;\n    return content + `\\n\\n${newContent} ${blockId}`;\n  }\n\n  if (operation === \"replace\") {\n    lines[blockIndex] = lines[blockIndex].replace(/^(.*?)(\\s+\\^\\w+)?$/, `${newContent} ${blockId}`);\n    return lines.join(\"\\n\");\n  }\n\n  if (operation === \"append\") {\n    lines.splice(blockIndex + 1, 0, newContent);\n    return lines.join(\"\\n\");\n  }\n\n  if (operation === \"prepend\") {\n    lines.splice(blockIndex, 0, newContent);\n    return lines.join(\"\\n\");\n  }\n\n  return content;\n}\n", "import { readdirSync, statSync } from \"fs\";\nimport { readFile } from \"fs/promises\";\nimport { join, relative } from \"path\";\n\nexport interface SearchMatch {\n  file: string;\n  line: number;\n  content: string;\n  contextBefore?: string;\n  contextAfter?: string;\n}\n\nexport async function searchInVault(\n  vaultPath: string,\n  query: string,\n  directory?: string,\n  contextLength: number = 100,\n): Promise<SearchMatch[]> {\n  const searchDir = directory ? join(vaultPath, directory) : vaultPath;\n  const results: SearchMatch[] = [];\n  const searchTerms = query.toLowerCase().split(/\\s+/).filter(Boolean);\n\n  await walkDir(searchDir, vaultPath, results, searchTerms, contextLength);\n  return results;\n}\n\nasync function walkDir(\n  dirPath: string,\n  vaultPath: string,\n  results: SearchMatch[],\n  searchTerms: string[],\n  contextLength: number,\n): Promise<void> {\n  let entries: string[];\n  try {\n    entries = readdirSync(dirPath);\n  } catch {\n    return;\n  }\n\n  for (const entry of entries) {\n    const fullPath = join(dirPath, entry);\n\n    let stat: ReturnType<typeof statSync>;\n    try {\n      stat = statSync(fullPath);\n    } catch {\n      continue;\n    }\n\n    if (stat.isDirectory()) {\n      if (!entry.startsWith(\".\")) {\n        await walkDir(fullPath, vaultPath, results, searchTerms, contextLength);\n      }\n      continue;\n    }\n\n    if (!entry.endsWith(\".md\")) continue;\n\n    try {\n      const content = await readFile(fullPath, \"utf-8\");\n      const lines = content.split(\"\\n\");\n      const relPath = relative(vaultPath, fullPath);\n\n      for (let i = 0; i < lines.length; i++) {\n        const lowerLine = lines[i].toLowerCase();\n        const matchesAll = searchTerms.every((term) => lowerLine.includes(term));\n\n        if (matchesAll) {\n          results.push({\n            file: relPath,\n            line: i + 1,\n            content: lines[i].substring(0, 500),\n            contextBefore: i > 0 ? lines[i - 1].substring(0, contextLength) : undefined,\n            contextAfter:\n              i < lines.length - 1 ? lines[i + 1].substring(0, contextLength) : undefined,\n          });\n        }\n      }\n    } catch {\n      // skip unreadable files\n    }\n  }\n}\n", "import {\n  listFiles,\n  readFileHandler,\n  createFile,\n  appendFile,\n  deleteFileHandler,\n  patchFile,\n} from \"../utils/fs-utils\";\nimport { searchInVault } from \"../utils/search\";\nimport type { VaultRegistry } from \"../utils/vaults\";\nimport type { ToolResult } from \"../mcp/protocol\";\n\ntype ToolHandler = (args: Record<string, any>) => Promise<ToolResult>;\n\nexport class VaultFileHandler {\n  private registry: VaultRegistry;\n\n  constructor(registry: VaultRegistry) {\n    this.registry = registry;\n  }\n\n  getHandlers(): Record<string, ToolHandler> {\n    return {\n      list_vaults: this.handleListVaults.bind(this),\n      get_vault_info: this.handleVaultInfo.bind(this),\n      list_files: this.handleListFiles.bind(this),\n      get_file: this.handleGetFile.bind(this),\n      create_file: this.handleCreateFile.bind(this),\n      append_to_file: this.handleAppendFile.bind(this),\n      patch_file: this.handlePatchFile.bind(this),\n      delete_file: this.handleDeleteFile.bind(this),\n      search: this.handleSearch.bind(this),\n    };\n  }\n\n  private resolveVault(args: Record<string, any>): string {\n    return this.registry.resolve(args.vault);\n  }\n\n  private async handleListVaults(_args: Record<string, any>): Promise<ToolResult> {\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: JSON.stringify(this.registry.list(), null, 2),\n        },\n      ],\n    };\n  }\n\n  private async handleVaultInfo(args: Record<string, any>): Promise<ToolResult> {\n    const info = this.registry.info(args.vault);\n    return {\n      content: [{ type: \"text\", text: JSON.stringify(info, null, 2) }],\n    };\n  }\n\n  private async handleListFiles(args: Record<string, any>): Promise<ToolResult> {\n    const vaultPath = this.resolveVault(args);\n    const entries = listFiles(vaultPath, args.directory);\n    return {\n      content: [{ type: \"text\", text: JSON.stringify(entries, null, 2) }],\n    };\n  }\n\n  private async handleGetFile(args: Record<string, any>): Promise<ToolResult> {\n    const vaultPath = this.resolveVault(args);\n    const result = await readFileHandler(vaultPath, args.filename);\n\n    if (args.format === \"json\") {\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(\n              {\n                filename: args.filename,\n                frontmatter: result.frontmatter,\n                content: result.content,\n              },\n              null,\n              2,\n            ),\n          },\n        ],\n      };\n    }\n\n    return { content: [{ type: \"text\", text: result.content }] };\n  }\n\n  private async handleCreateFile(args: Record<string, any>): Promise<ToolResult> {\n    const vaultPath = this.resolveVault(args);\n    await createFile(vaultPath, args.filename, args.content);\n    return {\n      content: [{ type: \"text\", text: \"File created successfully\" }],\n    };\n  }\n\n  private async handleAppendFile(args: Record<string, any>): Promise<ToolResult> {\n    const vaultPath = this.resolveVault(args);\n    await appendFile(vaultPath, args.filename, args.content);\n    return {\n      content: [{ type: \"text\", text: \"Content appended successfully\" }],\n    };\n  }\n\n  private async handlePatchFile(args: Record<string, any>): Promise<ToolResult> {\n    const vaultPath = this.resolveVault(args);\n    const result = await patchFile(\n      vaultPath,\n      args.filename,\n      args.operation,\n      args.targetType,\n      args.target,\n      args.content,\n      {\n        contentType: args.contentType,\n        targetDelimiter: args.targetDelimiter,\n        trimTargetWhitespace: args.trimTargetWhitespace,\n      },\n    );\n    return {\n      content: [\n        { type: \"text\", text: \"File patched successfully\" },\n        { type: \"text\", text: result },\n      ],\n    };\n  }\n\n  private async handleDeleteFile(args: Record<string, any>): Promise<ToolResult> {\n    const vaultPath = this.resolveVault(args);\n    deleteFileHandler(vaultPath, args.filename);\n    return {\n      content: [{ type: \"text\", text: \"File deleted successfully\" }],\n    };\n  }\n\n  private async handleSearch(args: Record<string, any>): Promise<ToolResult> {\n    const vaultPath = this.resolveVault(args);\n    const matches = await searchInVault(vaultPath, args.query, args.directory, args.contextLength);\n    return {\n      content: [{ type: \"text\", text: JSON.stringify(matches, null, 2) }],\n    };\n  }\n}\n", "import { readdirSync, statSync } from \"fs\";\nimport { readFile } from \"fs/promises\";\nimport { join } from \"path\";\nimport type { PromptDefinition } from \"../mcp/protocol\";\nimport type { VaultRegistry } from \"../utils/vaults\";\n\ninterface Frontmatter {\n  [key: string]: any;\n}\n\nfunction parseFrontmatter(content: string): { frontmatter: Frontmatter; body: string } | null {\n  if (!content.startsWith(\"---\")) return null;\n  const endIndex = content.indexOf(\"---\", 3);\n  if (endIndex === -1) return null;\n  const raw = content.slice(3, endIndex).trim();\n  const body = content.slice(endIndex + 3).trim();\n  const frontmatter: Frontmatter = {};\n  for (const line of raw.split(\"\\n\")) {\n    const colonIndex = line.indexOf(\":\");\n    if (colonIndex === -1) continue;\n    const key = line.slice(0, colonIndex).trim();\n    let value: any = line.slice(colonIndex + 1).trim();\n    if (value.startsWith('\"') && value.endsWith('\"')) value = value.slice(1, -1);\n    else if (value.startsWith(\"[\") && value.endsWith(\"]\")) {\n      value = value\n        .slice(1, -1)\n        .split(\",\")\n        .map((s: string) => s.trim().replace(/^[\"']|[\"']$/g, \"\"))\n        .filter(Boolean);\n    }\n    frontmatter[key] = value;\n  }\n  return { frontmatter, body };\n}\n\nexport class PromptHandler {\n  private registry: VaultRegistry;\n  private promptDir = \"Prompts\";\n\n  constructor(registry: VaultRegistry) {\n    this.registry = registry;\n  }\n\n  async list(vaultName?: string): Promise<PromptDefinition[]> {\n    const vaultPath = this.registry.resolve(vaultName);\n    const promptPath = join(vaultPath, this.promptDir);\n\n    let entries: string[];\n    try {\n      entries = readdirSync(promptPath);\n    } catch {\n      return [];\n    }\n\n    const prompts: PromptDefinition[] = [];\n\n    for (const entry of entries) {\n      if (!entry.endsWith(\".md\")) continue;\n\n      const fullPath = join(promptPath, entry);\n      const stat = statSync(fullPath);\n      if (!stat.isFile()) continue;\n\n      try {\n        const content = await readFile(fullPath, \"utf-8\");\n        const parsed = parseFrontmatter(content);\n        const tags: string[] = parsed?.frontmatter?.tags || [];\n\n        if (!tags.includes(\"mcp-tools-prompt\")) continue;\n\n        const promptArgs = parsePromptParameters(parsed?.body || content);\n        prompts.push({\n          name: entry,\n          description: parsed?.frontmatter?.description || entry.replace(\".md\", \"\"),\n          arguments: promptArgs,\n        });\n      } catch {\n        continue;\n      }\n    }\n\n    return prompts;\n  }\n\n  async get(\n    name: string,\n    vaultName?: string,\n  ): Promise<{\n    messages: Array<{ role: string; content: { type: string; text: string } }>;\n  }> {\n    const vaultPath = this.registry.resolve(vaultName);\n    const promptPath = join(vaultPath, this.promptDir, name);\n\n    let content: string;\n    try {\n      content = await readFile(promptPath, \"utf-8\");\n    } catch {\n      throw new Error(`Prompt not found: ${name}`);\n    }\n\n    const parsed = parseFrontmatter(content);\n    const body = parsed?.body || content;\n    const withoutFrontmatter = body.trim();\n\n    return {\n      messages: [\n        {\n          role: \"user\",\n          content: {\n            type: \"text\",\n            text: withoutFrontmatter,\n          },\n        },\n      ],\n    };\n  }\n}\n\ninterface PromptParameter {\n  name: string;\n  description?: string;\n  required?: boolean;\n}\n\nfunction parsePromptParameters(content: string): PromptParameter[] {\n  const regex = /<%[-_*]*\\s*tp\\.mcpTools\\.prompt\\(([^)]+)\\)\\s*[-_]*%>/g;\n  const params: PromptParameter[] = [];\n  let match: RegExpExecArray | null;\n\n  while ((match = regex.exec(content)) !== null) {\n    try {\n      const argsStr = match[1];\n      const args = argsStr.split(\",\").map((s) => s.trim().replace(/^[\"']|[\"']$/g, \"\"));\n\n      if (args.length >= 1) {\n        params.push({\n          name: args[0],\n          description: args[1],\n          required: true,\n        });\n      }\n    } catch {\n      continue;\n    }\n  }\n\n  return params;\n}\n", "import type { JSONRPCRequest, JSONRPCResponse, ToolDefinition } from \"./protocol\";\nimport { VaultFileHandler } from \"../handlers/tools\";\nimport { PromptHandler } from \"../handlers/prompts\";\nimport type { VaultRegistry } from \"../utils/vaults\";\n\nconst vaultParam = {\n  vault: {\n    type: \"string\",\n    description:\n      \"Vault name (derived from the directory name). Required when multiple vaults are configured.\",\n  },\n};\n\nexport interface ServerInstance {\n  toolDefinitions: ToolDefinition[];\n  handleRequest(msg: JSONRPCRequest): Promise<JSONRPCResponse | null>;\n}\n\nexport function createServer(registry: VaultRegistry): ServerInstance {\n  const vaultList = registry.list();\n  const vaultNames = vaultList.map((v) => v.name);\n  vaultParam.vault.description = `Vault name. Available: ${vaultNames.join(\", \")}`;\n\n  const fileHandler = new VaultFileHandler(registry);\n  const promptHandler = new PromptHandler(registry);\n  const toolHandlers = fileHandler.getHandlers();\n\n  const toolDefinitions: ToolDefinition[] = [\n    {\n      name: \"list_vaults\",\n      description: \"List all configured vaults with their paths.\",\n      inputSchema: { type: \"object\", properties: {} },\n    },\n    {\n      name: \"get_vault_info\",\n      description: \"Get stats for a vault (file count, path, name).\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          vault: {\n            type: \"string\",\n            description: `Vault name. Available: ${vaultNames.join(\", \")}`,\n          },\n        },\n      },\n    },\n    {\n      name: \"list_files\",\n      description: \"List files in the root directory or a specified subdirectory of your vault.\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          ...vaultParam,\n          directory: {\n            type: \"string\",\n            description: \"Optional subdirectory path relative to vault root\",\n          },\n        },\n      },\n    },\n    {\n      name: \"get_file\",\n      description: \"Get the content of a file from your vault.\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          ...vaultParam,\n          filename: {\n            type: \"string\",\n            description: \"Path to the file relative to vault root\",\n          },\n          format: {\n            type: \"string\",\n            enum: [\"markdown\", \"json\"],\n            description: \"Return format (json includes frontmatter)\",\n          },\n        },\n        required: [\"filename\"],\n      },\n    },\n    {\n      name: \"create_file\",\n      description: \"Create a new file in your vault or update an existing one.\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          ...vaultParam,\n          filename: {\n            type: \"string\",\n            description: \"Path to the file relative to vault root\",\n          },\n          content: { type: \"string\", description: \"File content\" },\n        },\n        required: [\"filename\", \"content\"],\n      },\n    },\n    {\n      name: \"append_to_file\",\n      description: \"Append content to a new or existing file.\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          ...vaultParam,\n          filename: {\n            type: \"string\",\n            description: \"Path to the file relative to vault root\",\n          },\n          content: {\n            type: \"string\",\n            description: \"Content to append\",\n          },\n        },\n        required: [\"filename\", \"content\"],\n      },\n    },\n    {\n      name: \"patch_file\",\n      description:\n        \"Insert or modify content in a file relative to a heading, block reference, or frontmatter field.\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          ...vaultParam,\n          filename: { type: \"string\" },\n          operation: {\n            type: \"string\",\n            enum: [\"append\", \"prepend\", \"replace\"],\n          },\n          targetType: {\n            type: \"string\",\n            enum: [\"heading\", \"block\", \"frontmatter\"],\n          },\n          target: { type: \"string\" },\n          content: { type: \"string\" },\n          contentType: {\n            type: \"string\",\n            enum: [\"text/markdown\", \"application/json\"],\n          },\n          targetDelimiter: { type: \"string\", default: \"::\" },\n          trimTargetWhitespace: { type: \"boolean\", default: true },\n        },\n        required: [\"filename\", \"operation\", \"targetType\", \"target\", \"content\"],\n      },\n    },\n    {\n      name: \"delete_file\",\n      description: \"Delete a file from your vault.\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          ...vaultParam,\n          filename: {\n            type: \"string\",\n            description: \"Path to the file relative to vault root\",\n          },\n        },\n        required: [\"filename\"],\n      },\n    },\n    {\n      name: \"search\",\n      description: \"Search for documents matching a text query in your vault.\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          ...vaultParam,\n          query: { type: \"string\", description: \"Text to search for\" },\n          directory: {\n            type: \"string\",\n            description: \"Optional directory to scope the search\",\n          },\n          contextLength: {\n            type: \"number\",\n            description: \"Characters of context around each match\",\n          },\n        },\n        required: [\"query\"],\n      },\n    },\n  ];\n\n  async function handleRequest(msg: JSONRPCRequest): Promise<JSONRPCResponse | null> {\n    const { method, params, id } = msg;\n\n    switch (method) {\n      case \"initialize\": {\n        const clientProtocol = params?.protocolVersion;\n        return {\n          jsonrpc: \"2.0\",\n          id,\n          result: {\n            protocolVersion: clientProtocol || \"2024-11-05\",\n            capabilities: { tools: {}, prompts: {} },\n            serverInfo: { name: \"obsidian-native-mcp\", version: \"0.2.0\" },\n          },\n        };\n      }\n\n      case \"tools/list\":\n        return {\n          jsonrpc: \"2.0\",\n          id,\n          result: { tools: toolDefinitions },\n        };\n\n      case \"tools/call\": {\n        const toolName = params?.name;\n        const args = params?.arguments || {};\n        const handler = toolHandlers[toolName as string];\n        if (!handler) {\n          return {\n            jsonrpc: \"2.0\",\n            id,\n            error: { code: -32601, message: `Unknown tool: ${toolName}` },\n          };\n        }\n        try {\n          const result = await handler(args);\n          return { jsonrpc: \"2.0\", id, result };\n        } catch (err: any) {\n          return {\n            jsonrpc: \"2.0\",\n            id,\n            error: { code: -32603, message: err.message || String(err) },\n          };\n        }\n      }\n\n      case \"prompts/list\": {\n        try {\n          const promptVault = params?.arguments?.vault;\n          const promptList = await promptHandler.list(promptVault);\n          return { jsonrpc: \"2.0\", id, result: { prompts: promptList } };\n        } catch (err: any) {\n          return {\n            jsonrpc: \"2.0\",\n            id,\n            error: { code: -32603, message: err.message || String(err) },\n          };\n        }\n      }\n\n      case \"prompts/get\": {\n        try {\n          const promptVault = params?.arguments?.vault;\n          const result = await promptHandler.get(params?.name, promptVault);\n          return { jsonrpc: \"2.0\", id, result };\n        } catch (err: any) {\n          return {\n            jsonrpc: \"2.0\",\n            id,\n            error: { code: -32603, message: err.message || String(err) },\n          };\n        }\n      }\n\n      case \"notifications/initialized\":\n      case \"notifications/cancelled\":\n      case \"notifications/roots/list_changed\":\n        return null;\n\n      default:\n        return {\n          jsonrpc: \"2.0\",\n          id,\n          error: { code: -32601, message: `Method not found: ${method}` },\n        };\n    }\n  }\n\n  return { toolDefinitions, handleRequest };\n}\n", "import { homedir, platform } from \"os\";\nimport { resolve, basename, join } from \"path\";\nimport { readFileSync, existsSync, readdirSync, statSync } from \"fs\";\n\nconst IS_WIN = platform() === \"win32\";\n\nexport interface VaultConfig {\n  name: string;\n  path: string;\n}\n\nexport class VaultRegistry {\n  private vaults: Map<string, string> = new Map();\n\n  constructor() {\n    const fromEnv = this.parseEnv();\n    const fromConfig = this.parseConfigFile();\n\n    if (fromEnv.length > 0) {\n      for (const v of fromEnv) this.vaults.set(v.name, v.path);\n    } else if (fromConfig.length > 0) {\n      for (const v of fromConfig) this.vaults.set(v.name, v.path);\n    }\n  }\n\n  configure(vaults: VaultConfig[]): void {\n    this.vaults.clear();\n    for (const v of vaults) {\n      this.vaults.set(v.name, v.path);\n    }\n  }\n\n  static discoverFromObsidian(): VaultConfig[] {\n    const configPath = obsidianConfigPath();\n    if (!configPath || !existsSync(configPath)) return [];\n\n    try {\n      const raw = readFileSync(configPath, \"utf-8\");\n      const config = JSON.parse(raw);\n      const vaults = config.vaults as Record<string, { path: string }>;\n      if (!vaults) return [];\n\n      return Object.entries(vaults)\n        .filter(([, v]) => v && typeof v.path === \"string\")\n        .map(([name, v]) => ({\n          name,\n          path: resolve(v.path.replace(/^~/, homedir())),\n        }));\n    } catch {\n      return [];\n    }\n  }\n\n  resolve(name?: string): string {\n    if (name) {\n      const path = this.vaults.get(name);\n      if (!path) {\n        const available = this.list()\n          .map((v) => v.name)\n          .join(\", \");\n        throw new Error(`Unknown vault \"${name}\". Available vaults: ${available}`);\n      }\n      return path;\n    }\n\n    if (this.vaults.size === 1) {\n      return this.vaults.values().next().value!;\n    }\n\n    const available = this.list()\n      .map((v) => v.name)\n      .join(\", \");\n    throw new Error(`Multiple vaults configured but no vault specified. Choose one: ${available}`);\n  }\n\n  list(): VaultConfig[] {\n    return Array.from(this.vaults.entries()).map(([name, path]) => ({\n      name,\n      path,\n    }));\n  }\n\n  info(name?: string): { name: string; path: string; fileCount: number } {\n    const vaultPath = this.resolve(name);\n    let fileCount = 0;\n    try {\n      const walkDir = (dir: string): void => {\n        for (const entry of readdirSync(dir)) {\n          const full = join(dir, entry);\n          try {\n            const stat = statSync(full);\n            if (stat.isDirectory()) {\n              if (!entry.startsWith(\".\")) walkDir(full);\n            } else if (entry.endsWith(\".md\")) {\n              fileCount++;\n            }\n          } catch {\n            // skip unreadable entries\n          }\n        }\n      };\n      walkDir(vaultPath);\n    } catch {\n      // skip unreadable directories\n    }\n    return { name: basename(vaultPath), path: vaultPath, fileCount };\n  }\n\n  private parseEnv(): VaultConfig[] {\n    const envVal = process.env.OBSIDIAN_VAULT_PATHS;\n    if (!envVal) return [];\n\n    const separator = /[;\\n]/;\n    const parts = envVal\n      .split(separator)\n      .map((s) => s.trim())\n      .filter(Boolean);\n\n    return parts.map((p) => {\n      const resolved = resolve(p.replace(/^~/, homedir()));\n      return { name: basename(resolved), path: resolved };\n    });\n  }\n\n  private configDir(): string {\n    if (IS_WIN) {\n      return resolve(\n        process.env.APPDATA || join(homedir(), \"AppData\", \"Roaming\"),\n        \"obsidian-native-mcp\",\n      );\n    }\n    const xdg = process.env.XDG_CONFIG_HOME;\n    if (xdg) return resolve(xdg, \"obsidian-native-mcp\");\n    return resolve(homedir(), \".config\", \"obsidian-native-mcp\");\n  }\n\n  private parseConfigFile(): VaultConfig[] {\n    const configPath = join(this.configDir(), \"vaults.json\");\n    if (!existsSync(configPath)) return [];\n\n    try {\n      const raw = readFileSync(configPath, \"utf-8\");\n      const config = JSON.parse(raw);\n      const resolved: VaultConfig[] = [];\n\n      const entries = config.vaults\n        ? (Object.entries(config.vaults) as [string, unknown][])\n        : (Object.entries(config).filter(([k]) => k !== \"default\") as [string, unknown][]);\n\n      for (const [name, path] of entries) {\n        if (typeof path === \"string\") {\n          resolved.push({ name, path: resolve(path.replace(/^~/, homedir())) });\n        }\n      }\n\n      return resolved;\n    } catch {\n      return [];\n    }\n  }\n}\n\nfunction obsidianConfigPath(): string | null {\n  if (IS_WIN) {\n    const appData = process.env.APPDATA;\n    if (!appData) return null;\n    return resolve(appData, \"obsidian\", \"obsidian.json\");\n  }\n  if (platform() === \"darwin\") {\n    return resolve(homedir(), \"Library\", \"Application Support\", \"obsidian\", \"obsidian.json\");\n  }\n  const xdg = process.env.XDG_CONFIG_HOME;\n  if (xdg) return resolve(xdg, \"obsidian\", \"obsidian.json\");\n  return resolve(homedir(), \".config\", \"obsidian\", \"obsidian.json\");\n}\n", "import { App, PluginSettingTab, Setting } from \"obsidian\";\nimport { VaultRegistry } from \"../utils/vaults\";\nimport type NativeMcpPlugin from \"./main\";\n\nexport class NativeMcpSettingTab extends PluginSettingTab {\n  private plugin: NativeMcpPlugin;\n\n  constructor(app: App, plugin: NativeMcpPlugin) {\n    super(app, plugin);\n    this.plugin = plugin;\n  }\n\n  display(): void {\n    const { containerEl } = this;\n    containerEl.empty();\n\n    containerEl.createEl(\"h2\", { text: \"Obsidian Native MCP\" });\n\n    const url = this.plugin.getServerUrl();\n    if (url) {\n      new Setting(containerEl)\n        .setName(\"MCP Server URL\")\n        .setDesc(\"Add this URL to your Claude Desktop config\")\n        .addText((text) => {\n          text.setValue(url).setDisabled(true);\n          text.inputEl.style.width = \"100%\";\n        })\n        .addButton((btn) => {\n          btn.setButtonText(\"Copy\").onClick(async () => {\n            await (navigator as any).clipboard.writeText(url);\n            btn.setButtonText(\"Copied!\");\n            setTimeout(() => btn.setButtonText(\"Copy\"), 2000);\n          });\n        });\n    } else {\n      new Setting(containerEl)\n        .setName(\"Server inactive\")\n        .setDesc(\"Select at least one vault below to start the MCP server.\");\n    }\n\n    containerEl.createEl(\"h3\", { text: \"Vaults\" });\n\n    const allVaults = VaultRegistry.discoverFromObsidian();\n    const selected = this.plugin.getSettings().selectedVaults;\n\n    if (allVaults.length === 0) {\n      containerEl.createEl(\"p\", {\n        text: \"No Obsidian vaults found. Make sure Obsidian has been started at least once.\",\n      });\n      return;\n    }\n\n    for (const vault of allVaults) {\n      const isSelected = selected.includes(vault.name);\n      new Setting(containerEl)\n        .setName(vault.name)\n        .setDesc(vault.path)\n        .addToggle((toggle) =>\n          toggle.setValue(isSelected).onChange(async (value) => {\n            const newSelected = value\n              ? [...selected, vault.name]\n              : selected.filter((n) => n !== vault.name);\n            await this.plugin.updateSelectedVaults(newSelected);\n            this.display();\n          }),\n        );\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": ["import_obsidian", "resolve", "http", "import_fs", "import_promises", "import_path", "import_fs", "import_promises", "import_path", "parseFrontmatter", "import_path", "import_fs", "available", "walkDir"]
}
