@mauricio.wolff/mcp-obsidian 0.4.1 → 0.5.1

package/dist/src/search.js

@@ -0,0 +1,105 @@
+import { join } from 'path';
+import { readFile, readdir } from 'node:fs/promises';
+export class SearchService {
+    vaultPath;
+    pathFilter;
+    constructor(vaultPath, pathFilter) {
+        this.vaultPath = vaultPath;
+        this.pathFilter = pathFilter;
+    }
+    async search(params) {
+        const { query, limit = 5, searchContent = true, searchFrontmatter = false, caseSensitive = false } = params;
+        if (!query || query.trim().length === 0) {
+            throw new Error('Search query cannot be empty');
+        }
+        const results = [];
+        const maxLimit = Math.min(limit, 20);
+        // Recursively find all .md files
+        const markdownFiles = await this.findMarkdownFiles(this.vaultPath);
+        for (const fullPath of markdownFiles) {
+            // Convert absolute path back to relative path
+            const relativePath = fullPath.substring(this.vaultPath.length + 1).replace(/\\/g, '/');
+            if (!this.pathFilter.isAllowed(relativePath))
+                continue;
+            if (results.length >= maxLimit)
+                break;
+            try {
+                const content = await readFile(fullPath, 'utf-8');
+                let searchableText = '';
+                // Prepare search text based on options
+                if (searchContent && searchFrontmatter) {
+                    searchableText = content;
+                }
+                else if (searchContent) {
+                    // Remove frontmatter from search
+                    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
+                    searchableText = frontmatterMatch ? content.slice(frontmatterMatch[0].length) : content;
+                }
+                else if (searchFrontmatter) {
+                    // Search only frontmatter
+                    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
+                    searchableText = frontmatterMatch ? frontmatterMatch[1] || '' : '';
+                }
+                const searchIn = caseSensitive ? searchableText : searchableText.toLowerCase();
+                const searchQuery = caseSensitive ? query : query.toLowerCase();
+                const index = searchIn.indexOf(searchQuery);
+                if (index !== -1) {
+                    // Extract excerpt around first match
+                    const excerptStart = Math.max(0, index - 50);
+                    const excerptEnd = Math.min(searchableText.length, index + searchQuery.length + 50);
+                    let excerpt = searchableText.slice(excerptStart, excerptEnd).trim();
+                    // Add ellipsis if excerpt is truncated
+                    if (excerptStart > 0)
+                        excerpt = '...' + excerpt;
+                    if (excerptEnd < searchableText.length)
+                        excerpt = excerpt + '...';
+                    // Count total matches
+                    let matchCount = 0;
+                    let searchIndex = 0;
+                    while ((searchIndex = searchIn.indexOf(searchQuery, searchIndex)) !== -1) {
+                        matchCount++;
+                        searchIndex += searchQuery.length;
+                    }
+                    // Find line number of first match
+                    const lines = searchableText.slice(0, index).split('\n');
+                    const lineNumber = lines.length;
+                    // Extract title from filename
+                    const title = relativePath.split('/').pop()?.replace(/\.md$/, '') || relativePath;
+                    results.push({
+                        path: relativePath,
+                        title: title,
+                        excerpt: excerpt,
+                        matchCount: matchCount,
+                        lineNumber: lineNumber
+                    });
+                }
+            }
+            catch (error) {
+                // Skip files that can't be read
+                continue;
+            }
+        }
+        return results;
+    }
+    async findMarkdownFiles(dirPath) {
+        const markdownFiles = [];
+        try {
+            const entries = await readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    // Recursively search subdirectories
+                    const subFiles = await this.findMarkdownFiles(fullPath);
+                    markdownFiles.push(...subFiles);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.md')) {
+                    markdownFiles.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories that can't be read
+        }
+        return markdownFiles;
+    }
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@mauricio.wolff/mcp-obsidian",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Lightweight MCP server for safe Obsidian vault access",
   "author": "bitbonsai",
   "license": "MIT",
   "type": "module",
   "main": "server.ts",
   "bin": {
-    "mcp-obsidian": "./server.ts",
-    "@mauricio.wolff/mcp-obsidian": "./server.ts"
+    "mcp-obsidian": "./dist/server.js",
+    "@mauricio.wolff/mcp-obsidian": "./dist/server.js"
   },
   "files": [
-    "server.ts",
-    "src/**/*",
+    "dist/**/*",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "start": "bun run server.ts",
-    "test": "bun test",
-    "test:watch": "bun test --watch",
-    "prepublishOnly": "bun test",
-    "prepack": "bun install",
+    "start": "tsx server.ts",
+    "build": "tsc --project tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build && npm test",
+    "prepack": "npm install",
     "publish:dry": "npm publish --dry-run",
     "publish:beta": "npm publish --tag beta",
     "publish:latest": "npm publish"
@@ -31,10 +31,15 @@
     "gray-matter": "^4.0.3"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0",
+    "js-yaml": "^4.1.0",
+    "@types/js-yaml": "^4.0.0"
   },
   "engines": {
-    "bun": ">=1.0.0"
+    "node": ">=18.0.0"
   },
   "repository": {
     "type": "git",
@@ -46,7 +51,7 @@
     "model-context-protocol",
     "claude",
     "ai",
-    "bun",
+    "node",
     "filesystem",
     "frontmatter",
     "yaml"

package/server.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -13,7 +13,7 @@ import { SearchService } from "./src/search.js";
 
 const vaultPath = process.argv[2];
 if (!vaultPath) {
-  console.error("Usage: bun server.ts /path/to/vault");
+  console.error("Usage: npx @mauricio.wolff/mcp-obsidian /path/to/vault");
   process.exit(1);
 }
 
@@ -25,7 +25,7 @@ const searchService = new SearchService(vaultPath, pathFilter);
 
 const server = new Server({
   name: "mcp-obsidian",
-  version: "0.3.0"
+  version: "0.5.1"
 }, {
   capabilities: {
     tools: {},