obsidian-vault-mcp 0.1.0 → 0.3.0

package/dist/index.js

@@ -174,6 +174,106 @@ const TOOLS = [
             properties: {},
         },
     },
+    {
+        name: 'update_note',
+        description: 'Update an existing note content',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Note path relative to vault' },
+                content: { type: 'string', description: 'New content (replaces entire file)' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    {
+        name: 'append_to_note',
+        description: 'Append content to the end of a note (useful for daily notes)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Note path relative to vault' },
+                content: { type: 'string', description: 'Content to append' },
+                separator: { type: 'string', default: '\n\n', description: 'Separator before appended content' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    {
+        name: 'delete_note',
+        description: 'Delete a note from the vault',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Note path relative to vault' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'rename_note',
+        description: 'Rename a note and update all links pointing to it',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                oldPath: { type: 'string', description: 'Current note path' },
+                newPath: { type: 'string', description: 'New note path' },
+            },
+            required: ['oldPath', 'newPath'],
+        },
+    },
+    {
+        name: 'get_outgoing_links',
+        description: 'Get all notes that the specified note links to',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Note path relative to vault' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'find_orphan_notes',
+        description: 'Find notes that have no incoming links (orphans)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                excludeFolders: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Folders to exclude (e.g., templates)',
+                },
+            },
+        },
+    },
+    {
+        name: 'find_broken_links',
+        description: 'Find all broken [[links]] in the vault',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'list_all_tags',
+        description: 'List all tags in the vault with their counts',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'extract_todos',
+        description: 'Extract all TODO items from the vault',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                includeCompleted: { type: 'boolean', default: false, description: 'Include completed tasks' },
+                path: { type: 'string', description: 'Limit to specific note or folder' },
+            },
+        },
+    },
 ];
 // 工具实现 - 使用 Orama BM25 搜索
 async function searchNotes(query, limit = 20) {
@@ -340,11 +440,366 @@ async function createNote(notePath, content, frontmatter) {
     });
     return `Created: ${notePath}`;
 }
+// 更新笔记
+async function updateNote(notePath, content) {
+    const fullPath = path.join(vaultPath, notePath);
+    // 确保文件存在
+    await fs.access(fullPath);
+    await fs.writeFile(fullPath, content, 'utf-8');
+    // 需要重建索引以反映更改
+    return `Updated: ${notePath}. Consider running rebuild_index for search to reflect changes.`;
+}
+// 追加到笔记
+async function appendToNote(notePath, content, separator = '\n\n') {
+    const fullPath = path.join(vaultPath, notePath);
+    const existing = await fs.readFile(fullPath, 'utf-8');
+    const newContent = existing + separator + content;
+    await fs.writeFile(fullPath, newContent, 'utf-8');
+    return `Appended to: ${notePath}`;
+}
+// 删除笔记
+async function deleteNote(notePath) {
+    const fullPath = path.join(vaultPath, notePath);
+    await fs.unlink(fullPath);
+    return `Deleted: ${notePath}. Consider running rebuild_index.`;
+}
+// 重命名笔记并更新链接
+async function renameNote(oldPath, newPath) {
+    const oldFullPath = path.join(vaultPath, oldPath);
+    const newFullPath = path.join(vaultPath, newPath);
+    // 确保源文件存在
+    await fs.access(oldFullPath);
+    // 确保目标目录存在
+    await fs.mkdir(path.dirname(newFullPath), { recursive: true });
+    // 移动文件
+    await fs.rename(oldFullPath, newFullPath);
+    // 更新所有指向旧路径的链接
+    const oldBasename = path.basename(oldPath, '.md');
+    const newBasename = path.basename(newPath, '.md');
+    let updatedFiles = 0;
+    async function updateLinks(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                await updateLinks(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                try {
+                    let content = await fs.readFile(fullPath, 'utf-8');
+                    let modified = false;
+                    // 替换 [[oldBasename]] 和 [[oldBasename|alias]]
+                    const patterns = [
+                        new RegExp(`\\[\\[${escapeRegExp(oldBasename)}\\]\\]`, 'g'),
+                        new RegExp(`\\[\\[${escapeRegExp(oldBasename)}\\|`, 'g'),
+                        new RegExp(`\\[\\[${escapeRegExp(oldPath)}\\]\\]`, 'g'),
+                        new RegExp(`\\[\\[${escapeRegExp(oldPath)}\\|`, 'g'),
+                    ];
+                    const replacements = [
+                        `[[${newBasename}]]`,
+                        `[[${newBasename}|`,
+                        `[[${newPath}]]`,
+                        `[[${newPath}|`,
+                    ];
+                    for (let i = 0; i < patterns.length; i++) {
+                        if (patterns[i].test(content)) {
+                            content = content.replace(patterns[i], replacements[i]);
+                            modified = true;
+                        }
+                    }
+                    if (modified) {
+                        await fs.writeFile(fullPath, content, 'utf-8');
+                        updatedFiles++;
+                    }
+                }
+                catch {
+                    // 忽略
+                }
+            }
+        }
+    }
+    await updateLinks(vaultPath);
+    return {
+        renamed: `${oldPath} -> ${newPath}`,
+        linksUpdated: updatedFiles,
+        message: 'Consider running rebuild_index.',
+    };
+}
+// 辅助函数：转义正则特殊字符
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// 获取外链
+async function getOutgoingLinks(notePath) {
+    const fullPath = path.join(vaultPath, notePath);
+    const content = await fs.readFile(fullPath, 'utf-8');
+    // 提取 [[link]] 和 [[link|alias]]
+    const linkMatches = content.match(/\[\[([^\]]+)\]\]/g) || [];
+    const links = [];
+    for (const match of linkMatches) {
+        const inner = match.slice(2, -2);
+        const [target, alias] = inner.split('|');
+        // 检查目标是否存在
+        let targetPath = target;
+        if (!targetPath.endsWith('.md')) {
+            targetPath += '.md';
+        }
+        let exists = false;
+        try {
+            await fs.access(path.join(vaultPath, targetPath));
+            exists = true;
+        }
+        catch {
+            // 尝试搜索
+            try {
+                const found = await findNoteByName(target);
+                exists = found !== null;
+            }
+            catch {
+                exists = false;
+            }
+        }
+        links.push({
+            target: target,
+            ...(alias ? { alias } : {}),
+            exists,
+        });
+    }
+    // 去重
+    const seen = new Set();
+    return links.filter(link => {
+        if (seen.has(link.target))
+            return false;
+        seen.add(link.target);
+        return true;
+    });
+}
+// 辅助函数：按名称查找笔记
+async function findNoteByName(name) {
+    const searchName = name.endsWith('.md') ? name : `${name}.md`;
+    async function searchDir(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                const found = await searchDir(fullPath);
+                if (found)
+                    return found;
+            }
+            else if (entry.isFile() && entry.name === searchName) {
+                return path.relative(vaultPath, fullPath);
+            }
+        }
+        return null;
+    }
+    return searchDir(vaultPath);
+}
+// 查找孤立笔记
+async function findOrphanNotes(excludeFolders = []) {
+    const allNotes = [];
+    const linkedNotes = new Set();
+    // 收集所有笔记和链接
+    async function collectNotes(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.relative(vaultPath, fullPath);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                // 检查是否在排除列表中
+                if (excludeFolders.some(folder => relativePath.startsWith(folder))) {
+                    continue;
+                }
+                await collectNotes(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                allNotes.push(relativePath);
+                try {
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    const linkMatches = content.match(/\[\[([^\]|]+)/g) || [];
+                    for (const match of linkMatches) {
+                        const target = match.slice(2);
+                        linkedNotes.add(target);
+                        linkedNotes.add(target + '.md');
+                        linkedNotes.add(path.basename(target));
+                        linkedNotes.add(path.basename(target, '.md'));
+                    }
+                }
+                catch {
+                    // 忽略
+                }
+            }
+        }
+    }
+    await collectNotes(vaultPath);
+    // 找出没有被链接的笔记
+    return allNotes.filter(note => {
+        const basename = path.basename(note, '.md');
+        return !linkedNotes.has(note) &&
+            !linkedNotes.has(basename) &&
+            !linkedNotes.has(note.replace('.md', ''));
+    });
+}
+// 查找损坏的链接
+async function findBrokenLinks() {
+    const brokenLinks = [];
+    const existingNotes = new Set();
+    // 首先收集所有存在的笔记
+    async function collectExisting(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                await collectExisting(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                const relativePath = path.relative(vaultPath, fullPath);
+                existingNotes.add(relativePath);
+                existingNotes.add(relativePath.replace('.md', ''));
+                existingNotes.add(path.basename(relativePath));
+                existingNotes.add(path.basename(relativePath, '.md'));
+            }
+        }
+    }
+    await collectExisting(vaultPath);
+    // 检查所有链接
+    async function checkLinks(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                await checkLinks(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                try {
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    const linkMatches = content.match(/\[\[([^\]|]+)/g) || [];
+                    const sourcePath = path.relative(vaultPath, fullPath);
+                    for (const match of linkMatches) {
+                        const target = match.slice(2);
+                        // 跳过外部链接和特殊链接
+                        if (target.includes('://') || target.startsWith('#'))
+                            continue;
+                        // 检查是否存在
+                        if (!existingNotes.has(target) &&
+                            !existingNotes.has(target + '.md') &&
+                            !existingNotes.has(path.basename(target)) &&
+                            !existingNotes.has(path.basename(target, '.md'))) {
+                            brokenLinks.push({ source: sourcePath, target });
+                        }
+                    }
+                }
+                catch {
+                    // 忽略
+                }
+            }
+        }
+    }
+    await checkLinks(vaultPath);
+    return brokenLinks;
+}
+// 列出所有标签
+async function listAllTags() {
+    const tagCounts = {};
+    async function collectTags(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                await collectTags(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                try {
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    const tagMatches = content.match(/#[\w\u4e00-\u9fa5/-]+/g) || [];
+                    for (const tag of tagMatches) {
+                        const normalizedTag = tag.slice(1); // 去掉 #
+                        tagCounts[normalizedTag] = (tagCounts[normalizedTag] || 0) + 1;
+                    }
+                }
+                catch {
+                    // 忽略
+                }
+            }
+        }
+    }
+    await collectTags(vaultPath);
+    // 按计数排序
+    const sorted = Object.entries(tagCounts)
+        .sort((a, b) => b[1] - a[1])
+        .map(([tag, count]) => ({ tag, count }));
+    return {
+        total: sorted.length,
+        tags: sorted,
+    };
+}
+// 提取待办事项
+async function extractTodos(includeCompleted = false, limitPath) {
+    const todos = [];
+    const startDir = limitPath ? path.join(vaultPath, limitPath) : vaultPath;
+    async function collectTodos(dir) {
+        let entries;
+        try {
+            const stat = await fs.stat(dir);
+            if (stat.isFile()) {
+                // 如果是文件，直接处理
+                await processFile(dir);
+                return;
+            }
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                await collectTodos(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                await processFile(fullPath);
+            }
+        }
+    }
+    async function processFile(fullPath) {
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            const lines = content.split('\n');
+            const relativePath = path.relative(vaultPath, fullPath);
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // 匹配 - [ ] 和 - [x]
+                const unchecked = line.match(/^(\s*)-\s+\[\s*\]\s+(.+)$/);
+                const checked = line.match(/^(\s*)-\s+\[[xX]\]\s+(.+)$/);
+                if (unchecked) {
+                    todos.push({
+                        path: relativePath,
+                        line: i + 1,
+                        text: unchecked[2],
+                        completed: false,
+                    });
+                }
+                else if (checked && includeCompleted) {
+                    todos.push({
+                        path: relativePath,
+                        line: i + 1,
+                        text: checked[2],
+                        completed: true,
+                    });
+                }
+            }
+        }
+        catch {
+            // 忽略
+        }
+    }
+    await collectTodos(startDir);
+    return todos;
+}
 // 创建 MCP 服务器
 async function main() {
     await validateVaultPath();
     await buildSearchIndex();
-    const server = new Server({ name: 'obsidian-vault-mcp', version: '0.2.0' }, { capabilities: { tools: {} } });
+    const server = new Server({ name: 'obsidian-vault-mcp', version: '0.3.0' }, { capabilities: { tools: {} } });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: TOOLS,
     }));
@@ -378,6 +833,33 @@ async function main() {
                     await buildSearchIndex();
                     result = 'Index rebuilt successfully';
                     break;
+                case 'update_note':
+                    result = await updateNote(args?.path, args?.content);
+                    break;
+                case 'append_to_note':
+                    result = await appendToNote(args?.path, args?.content, args?.separator);
+                    break;
+                case 'delete_note':
+                    result = await deleteNote(args?.path);
+                    break;
+                case 'rename_note':
+                    result = await renameNote(args?.oldPath, args?.newPath);
+                    break;
+                case 'get_outgoing_links':
+                    result = await getOutgoingLinks(args?.path);
+                    break;
+                case 'find_orphan_notes':
+                    result = await findOrphanNotes(args?.excludeFolders);
+                    break;
+                case 'find_broken_links':
+                    result = await findBrokenLinks();
+                    break;
+                case 'list_all_tags':
+                    result = await listAllTags();
+                    break;
+                case 'extract_todos':
+                    result = await extractTodos(args?.includeCompleted, args?.path);
+                    break;
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }
@@ -394,7 +876,7 @@ async function main() {
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`Obsidian Vault MCP Server v0.2.0 (BM25)`);
+    console.error(`Obsidian Vault MCP Server v0.3.0 (18 tools)`);
     console.error(`Vault: ${vaultPath}`);
 }
 main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-vault-mcp",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "MCP server for Obsidian vault with BM25 search, backlinks, tags, and more",
   "main": "dist/index.js",
   "type": "module",