obsidian-native-mcp 0.2.0

package/src/utils/fs-utils.ts

@@ -0,0 +1,358 @@
+import { readdirSync, statSync, unlinkSync, mkdirSync, existsSync } from "fs";
+import { readFile, writeFile, access } from "fs/promises";
+import { join, dirname, relative } from "path";
+
+export interface FileEntry {
+  name: string;
+  path: string;
+  type: "file" | "directory";
+  size?: number;
+  mtime?: Date;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readTextFile(path: string): Promise<string> {
+  return readFile(path, "utf-8");
+}
+
+async function writeTextFile(path: string, content: string): Promise<void> {
+  await writeFile(path, content, "utf-8");
+}
+
+export function listFiles(vaultPath: string, directory?: string): FileEntry[] {
+  const targetDir = directory ? join(vaultPath, directory) : vaultPath;
+
+  if (!existsSync(targetDir)) {
+    throw new Error(`Directory not found: ${targetDir}`);
+  }
+
+  const entries = readdirSync(targetDir);
+  const result: FileEntry[] = [];
+
+  for (const entry of entries) {
+    const fullPath = join(targetDir, entry);
+    const stat = statSync(fullPath);
+    result.push({
+      name: entry,
+      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);
+  });
+}
+
+export async function readFileHandler(
+  vaultPath: string,
+  filename: string,
+): Promise<{ content: string; frontmatter?: Record<string, any> }> {
+  const fullPath = join(vaultPath, filename);
+
+  if (!(await fileExists(fullPath))) {
+    throw new Error(`File not found: ${filename}`);
+  }
+
+  const stat = 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,
+  };
+}
+
+export async function createFile(
+  vaultPath: string,
+  filename: string,
+  content: string,
+): Promise<void> {
+  const fullPath = join(vaultPath, filename);
+  const dir = dirname(fullPath);
+
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  await writeTextFile(fullPath, content);
+}
+
+export async function appendFile(
+  vaultPath: string,
+  filename: string,
+  content: string,
+): Promise<void> {
+  const fullPath = join(vaultPath, filename);
+  const dir = dirname(fullPath);
+
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  let existing = "";
+  if (await fileExists(fullPath)) {
+    existing = await readTextFile(fullPath);
+  }
+
+  await writeTextFile(fullPath, existing + content);
+}
+
+export function deleteFileHandler(vaultPath: string, filename: string): void {
+  const fullPath = join(vaultPath, filename);
+
+  if (!existsSync(fullPath)) {
+    throw new Error(`File not found: ${filename}`);
+  }
+
+  unlinkSync(fullPath);
+}
+
+export async function patchFile(
+  vaultPath: string,
+  filename: string,
+  operation: "append" | "prepend" | "replace",
+  targetType: "heading" | "block" | "frontmatter",
+  target: string,
+  content: string,
+  options?: {
+    contentType?: string;
+    targetDelimiter?: string;
+    trimTargetWhitespace?: boolean;
+  },
+): Promise<string> {
+  const fullPath = join(vaultPath, filename);
+
+  if (!(await fileExists(fullPath))) {
+    throw new Error(`File not found: ${filename}`);
+  }
+
+  const fileContent = await readTextFile(fullPath);
+  let modified: string;
+
+  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: string,
+): { frontmatter: Record<string, any>; body: string } | null {
+  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: Record<string, any> = {};
+
+  for (const line of raw.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value: any = 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: string) => s.trim().replace(/^["']|["']$/g, ""))
+        .filter(Boolean);
+    }
+
+    frontmatter[key] = value;
+  }
+
+  return { frontmatter, body };
+}
+
+function patchFrontmatter(
+  content: string,
+  operation: "append" | "prepend" | "replace",
+  target: string,
+  newContent: string,
+): string {
+  const parsed = parseFrontmatter(content);
+
+  if (operation === "replace" && target === "all") {
+    if (parsed) {
+      return `---\n${newContent}\n---\n\n${parsed.body}`;
+    }
+    return `---\n${newContent}\n---\n\n${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 `---\n${target}: ${newContent}\n---\n\n${content}`;
+  }
+
+  return content;
+}
+
+function findHeadingLine(
+  lines: string[],
+  target: string,
+  delimiter: string,
+): { lineIndex: number; level: number } | null {
+  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: string[], startLine: number, level: number): number {
+  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: string,
+  operation: "append" | "prepend" | "replace",
+  target: string,
+  newContent: string,
+  options?: any,
+): string {
+  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 + `\n\n## ${lastPart}\n\n${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: string,
+  operation: "append" | "prepend" | "replace",
+  target: string,
+  newContent: string,
+): string {
+  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 + `\n\n${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;
+}

package/src/utils/search.ts

@@ -0,0 +1,84 @@
+import { readdirSync, statSync } from "fs";
+import { readFile } from "fs/promises";
+import { join, relative } from "path";
+
+export interface SearchMatch {
+  file: string;
+  line: number;
+  content: string;
+  contextBefore?: string;
+  contextAfter?: string;
+}
+
+export async function searchInVault(
+  vaultPath: string,
+  query: string,
+  directory?: string,
+  contextLength: number = 100,
+): Promise<SearchMatch[]> {
+  const searchDir = directory ? join(vaultPath, directory) : vaultPath;
+  const results: SearchMatch[] = [];
+  const searchTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+
+  await walkDir(searchDir, vaultPath, results, searchTerms, contextLength);
+  return results;
+}
+
+async function walkDir(
+  dirPath: string,
+  vaultPath: string,
+  results: SearchMatch[],
+  searchTerms: string[],
+  contextLength: number,
+): Promise<void> {
+  let entries: string[];
+  try {
+    entries = readdirSync(dirPath);
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+
+    let stat: ReturnType<typeof statSync>;
+    try {
+      stat = 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 readFile(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const relPath = 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) : undefined,
+            contextAfter:
+              i < lines.length - 1 ? lines[i + 1].substring(0, contextLength) : undefined,
+          });
+        }
+      }
+    } catch {
+      // skip unreadable files
+    }
+  }
+}

package/src/utils/vaults.ts

@@ -0,0 +1,175 @@
+import { homedir, platform } from "os";
+import { resolve, basename, join } from "path";
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+
+const IS_WIN = platform() === "win32";
+
+export interface VaultConfig {
+  name: string;
+  path: string;
+}
+
+export class VaultRegistry {
+  private vaults: Map<string, string> = 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: VaultConfig[]): void {
+    this.vaults.clear();
+    for (const v of vaults) {
+      this.vaults.set(v.name, v.path);
+    }
+  }
+
+  static discoverFromObsidian(): VaultConfig[] {
+    const configPath = obsidianConfigPath();
+    if (!configPath || !existsSync(configPath)) return [];
+
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      const vaults = config.vaults as Record<string, { path: string }>;
+      if (!vaults) return [];
+
+      return Object.entries(vaults)
+        .filter(([, v]) => v && typeof v.path === "string")
+        .map(([name, v]) => ({
+          name,
+          path: resolve(v.path.replace(/^~/, homedir())),
+        }));
+    } catch {
+      return [];
+    }
+  }
+
+  resolve(name?: string): string {
+    if (name) {
+      const path = this.vaults.get(name);
+      if (!path) {
+        const available = this.list()
+          .map((v) => v.name)
+          .join(", ");
+        throw new Error(`Unknown vault "${name}". Available vaults: ${available}`);
+      }
+      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(): VaultConfig[] {
+    return Array.from(this.vaults.entries()).map(([name, path]) => ({
+      name,
+      path,
+    }));
+  }
+
+  info(name?: string): { name: string; path: string; fileCount: number } {
+    const vaultPath = this.resolve(name);
+    let fileCount = 0;
+    try {
+      const walkDir = (dir: string): void => {
+        for (const entry of readdirSync(dir)) {
+          const full = join(dir, entry);
+          try {
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+              if (!entry.startsWith(".")) walkDir(full);
+            } else if (entry.endsWith(".md")) {
+              fileCount++;
+            }
+          } catch {
+            // skip unreadable entries
+          }
+        }
+      };
+      walkDir(vaultPath);
+    } catch {
+      // skip unreadable directories
+    }
+    return { name: basename(vaultPath), path: vaultPath, fileCount };
+  }
+
+  private parseEnv(): VaultConfig[] {
+    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 = resolve(p.replace(/^~/, homedir()));
+      return { name: basename(resolved), path: resolved };
+    });
+  }
+
+  private configDir(): string {
+    if (IS_WIN) {
+      return resolve(
+        process.env.APPDATA || join(homedir(), "AppData", "Roaming"),
+        "obsidian-native-mcp",
+      );
+    }
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg) return resolve(xdg, "obsidian-native-mcp");
+    return resolve(homedir(), ".config", "obsidian-native-mcp");
+  }
+
+  private parseConfigFile(): VaultConfig[] {
+    const configPath = join(this.configDir(), "vaults.json");
+    if (!existsSync(configPath)) return [];
+
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      const resolved: VaultConfig[] = [];
+
+      const entries = config.vaults
+        ? (Object.entries(config.vaults) as [string, unknown][])
+        : (Object.entries(config).filter(([k]) => k !== "default") as [string, unknown][]);
+
+      for (const [name, path] of entries) {
+        if (typeof path === "string") {
+          resolved.push({ name, path: resolve(path.replace(/^~/, homedir())) });
+        }
+      }
+
+      return resolved;
+    } catch {
+      return [];
+    }
+  }
+}
+
+function obsidianConfigPath(): string | null {
+  if (IS_WIN) {
+    const appData = process.env.APPDATA;
+    if (!appData) return null;
+    return resolve(appData, "obsidian", "obsidian.json");
+  }
+  if (platform() === "darwin") {
+    return resolve(homedir(), "Library", "Application Support", "obsidian", "obsidian.json");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return resolve(xdg, "obsidian", "obsidian.json");
+  return resolve(homedir(), ".config", "obsidian", "obsidian.json");
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "lib": ["ES2022"],
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["node"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "declaration": false
+  },
+  "include": ["src"]
+}