@mauricio.wolff/mcp-obsidian 0.7.4 → 0.8.1

package/dist/src/search.js

@@ -13,19 +13,36 @@ export class SearchService {
         if (!query || query.trim().length === 0) {
             throw new Error('Search query cannot be empty');
         }
-        const results = [];
         const maxLimit = Math.min(limit, 20);
+        // Corpus stats for reranking
+        let totalDocLength = 0;
+        let docCount = 0;
+        const termDocFreq = new Map();
+        const candidates = [];
+        const searchQuery = caseSensitive ? query : query.toLowerCase();
+        const terms = searchQuery.split(/\s+/).filter(t => t.length > 0);
+        const scoringTerms = terms.length > 1 ? [...terms, searchQuery] : terms;
         // Recursively find all .md files
         const markdownFiles = await this.findMarkdownFiles(this.vaultPath);
+        // Pre-filter by pathFilter before I/O
+        const prefixLen = this.vaultPath.length + 1;
+        const allowedFiles = [];
         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');
+            const relativePath = fullPath.substring(prefixLen).replace(/\\/g, '/');
+            if (this.pathFilter.isAllowed(relativePath)) {
+                allowedFiles.push({ fullPath, relativePath });
+            }
+        }
+        // Read files in parallel batches
+        const BATCH_SIZE = 5;
+        for (let start = 0; start < allowedFiles.length; start += BATCH_SIZE) {
+            const batch = allowedFiles.slice(start, start + BATCH_SIZE);
+            const contents = await Promise.all(batch.map(f => readFile(f.fullPath, 'utf-8').catch(() => null)));
+            for (let i = 0; i < batch.length; i++) {
+                const content = contents[i];
+                if (content === null || content === undefined)
+                    continue;
+                const { relativePath } = batch[i];
                 let searchableText = '';
                 // Prepare search text based on options
                 if (searchContent && searchFrontmatter) {
@@ -42,45 +59,86 @@ export class SearchService {
                     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 - 21);
-                    const excerptEnd = Math.min(searchableText.length, index + searchQuery.length + 21);
-                    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
+                // Collect corpus stats for reranking
+                const docLength = searchIn.split(/\s+/).filter(w => w.length > 0).length;
+                totalDocLength += docLength;
+                docCount++;
+                for (const term of scoringTerms) {
+                    if (searchIn.includes(term)) {
+                        termDocFreq.set(term, (termDocFreq.get(term) || 0) + 1);
+                    }
+                }
+                // Extract title from filename
+                const title = relativePath.split('/').pop()?.replace(/\.md$/, '') || relativePath;
+                // Check filename match (any term)
+                const filenameToSearch = caseSensitive ? title : title.toLowerCase();
+                const filenameMatch = terms.some(term => filenameToSearch.includes(term));
+                // Check content match (any term)
+                const termIndices = terms.map(term => searchIn.indexOf(term));
+                const anyTermFound = termIndices.some(idx => idx !== -1);
+                const firstIndex = anyTermFound
+                    ? Math.min(...termIndices.filter(idx => idx !== -1))
+                    : -1;
+                if (firstIndex !== -1 || filenameMatch) {
+                    let excerpt;
                     let matchCount = 0;
-                    let searchIndex = 0;
-                    while ((searchIndex = searchIn.indexOf(searchQuery, searchIndex)) !== -1) {
-                        matchCount++;
-                        searchIndex += searchQuery.length;
+                    let lineNumber = 0;
+                    const termFreqs = new Map();
+                    if (firstIndex !== -1) {
+                        // Find the term that matched first for excerpt
+                        const firstTermIdx = termIndices.indexOf(firstIndex);
+                        const firstTerm = terms[firstTermIdx];
+                        // Extract excerpt around first content match
+                        const excerptStart = Math.max(0, firstIndex - 21);
+                        const excerptEnd = Math.min(searchableText.length, firstIndex + firstTerm.length + 21);
+                        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 content matches across all terms
+                        for (const term of scoringTerms) {
+                            let count = 0;
+                            let searchIndex = 0;
+                            while ((searchIndex = searchIn.indexOf(term, searchIndex)) !== -1) {
+                                count++;
+                                searchIndex += term.length;
+                            }
+                            termFreqs.set(term, count);
+                            matchCount += count;
+                        }
+                        // Find line number of first match
+                        const lines = searchableText.slice(0, firstIndex).split('\n');
+                        lineNumber = lines.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({
-                        p: relativePath,
-                        t: title,
-                        ex: excerpt,
-                        mc: matchCount,
-                        ln: lineNumber,
-                        uri: generateObsidianUri(this.vaultPath, relativePath)
+                    else {
+                        // Filename-only match: use beginning of content as excerpt
+                        excerpt = searchableText.slice(0, 50).trim();
+                        if (searchableText.length > 50)
+                            excerpt = excerpt + '...';
+                        matchCount = 0;
+                        lineNumber = 0;
+                    }
+                    // Add filename match to count
+                    if (filenameMatch)
+                        matchCount++;
+                    candidates.push({
+                        result: {
+                            p: relativePath,
+                            t: title,
+                            ex: excerpt,
+                            mc: matchCount,
+                            ln: lineNumber,
+                            uri: generateObsidianUri(this.vaultPath, relativePath)
+                        },
+                        termFreqs,
+                        docLength
                     });
                 }
             }
-            catch (error) {
-                // Skip files that can't be read
-                continue;
-            }
         }
+        const results = this.rerank(candidates, scoringTerms, termDocFreq, docCount, totalDocLength, maxLimit);
         return results;
     }
     async findMarkdownFiles(dirPath) {
@@ -104,4 +162,21 @@ export class SearchService {
         }
         return markdownFiles;
     }
+    rerank(candidates, terms, termDocFreq, docCount, totalDocLength, maxLimit) {
+        const avgdl = docCount > 0 ? totalDocLength / docCount : 1;
+        const k1 = 1.2;
+        const b = 0.75;
+        const scored = candidates.map(c => {
+            let score = 0;
+            for (const term of terms) {
+                const tf = c.termFreqs.get(term) || 0;
+                const df = termDocFreq.get(term) || 0;
+                const idf = Math.log(1 + (docCount - df + 0.5) / (df + 0.5));
+                score += idf * (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * c.docLength / avgdl));
+            }
+            return { score, result: c.result };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, maxLimit).map(s => s.result);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mauricio.wolff/mcp-obsidian",
-  "version": "0.7.4",
+  "version": "0.8.1",
   "description": "Universal AI bridge for Obsidian vaults - connect any MCP-compatible assistant",
   "author": "bitbonsai",
   "license": "MIT",
@@ -18,6 +18,7 @@
   ],
   "scripts": {
     "start": "tsx server.ts",
+    "website": "cd website && bun dev",
     "build": "tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:watch": "vitest",