@fromsko/obsidian-mcp-server 1.1.9 → 1.2.0

package/dist/services/notes.js

@@ -0,0 +1,211 @@
+import * as fs from "fs/promises";
+import { glob } from "glob";
+import matter from "gray-matter";
+import * as path from "path";
+export function createNoteService(vaultPath) {
+    async function parseNote(filePath) {
+        try {
+            const content = await fs.readFile(filePath, "utf-8");
+            const { data } = matter(content);
+            const relativePath = path.relative(vaultPath, filePath);
+            return {
+                path: relativePath,
+                name: path.basename(filePath, ".md"),
+                category: data.category,
+                tags: data.tags,
+                summary: data.summary,
+                folder: data.folder,
+                created: data.created,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async function getAllNotes() {
+        const files = await glob("**/*.md", {
+            cwd: vaultPath,
+            ignore: [".obsidian/**", ".smart-env/**", ".windsurf/**"],
+        });
+        const notes = [];
+        for (const file of files) {
+            const meta = await parseNote(path.join(vaultPath, file));
+            if (meta)
+                notes.push(meta);
+        }
+        return notes;
+    }
+    async function searchNotes(query, tag, category) {
+        const allNotes = await getAllNotes();
+        return allNotes.filter((note) => {
+            const matchesQuery = !query ||
+                note.name.toLowerCase().includes(query.toLowerCase()) ||
+                note.summary?.toLowerCase().includes(query.toLowerCase());
+            const matchesTag = !tag || note.tags?.includes(tag);
+            const matchesCategory = !category || note.category === category;
+            return matchesQuery && matchesTag && matchesCategory;
+        });
+    }
+    async function readNote(notePath) {
+        const fullPath = path.join(vaultPath, notePath);
+        try {
+            return await fs.readFile(fullPath, "utf-8");
+        }
+        catch {
+            throw new Error(`笔记不存在: ${notePath}`);
+        }
+    }
+    async function listFolder(folderPath = "") {
+        const targetPath = path.join(vaultPath, folderPath);
+        const entries = await fs.readdir(targetPath, { withFileTypes: true });
+        const folders = [];
+        const notes = [];
+        for (const entry of entries) {
+            if (entry.name.startsWith("."))
+                continue;
+            if (entry.isDirectory()) {
+                folders.push(entry.name);
+            }
+            else if (entry.name.endsWith(".md")) {
+                const meta = await parseNote(path.join(targetPath, entry.name));
+                if (meta)
+                    notes.push(meta);
+            }
+        }
+        return { folders, notes };
+    }
+    async function getNoteStructure() {
+        const rootContent = await listFolder("");
+        const structure = {
+            _notes: rootContent.notes.map((n) => n.name),
+        };
+        for (const folder of rootContent.folders) {
+            try {
+                const subContent = await listFolder(folder);
+                structure[folder] = {
+                    folders: subContent.folders,
+                    notes: subContent.notes.map((n) => n.name),
+                };
+            }
+            catch {
+                structure[folder] = { error: "无法读取" };
+            }
+        }
+        return structure;
+    }
+    async function createNote(notePath, content) {
+        const fullPath = path.join(vaultPath, notePath);
+        const dir = path.dirname(fullPath);
+        await fs.mkdir(dir, { recursive: true });
+        try {
+            await fs.access(fullPath);
+            throw new Error(`笔记已存在: ${notePath}`);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        await fs.writeFile(fullPath, content, "utf-8");
+        return `笔记创建成功: ${notePath}`;
+    }
+    async function updateNote(notePath, content) {
+        const fullPath = path.join(vaultPath, notePath);
+        try {
+            await fs.access(fullPath);
+        }
+        catch {
+            throw new Error(`笔记不存在: ${notePath}`);
+        }
+        await fs.writeFile(fullPath, content, "utf-8");
+        return `笔记更新成功: ${notePath}`;
+    }
+    async function deleteNote(notePath) {
+        const fullPath = path.join(vaultPath, notePath);
+        try {
+            await fs.access(fullPath);
+        }
+        catch {
+            throw new Error(`笔记不存在: ${notePath}`);
+        }
+        await fs.unlink(fullPath);
+        return `笔记删除成功: ${notePath}`;
+    }
+    async function createFolder(folderPath) {
+        const fullPath = path.join(vaultPath, folderPath);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory()) {
+                throw new Error(`文件夹已存在: ${folderPath}`);
+            }
+            throw new Error(`路径已存在但不是文件夹: ${folderPath}`);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        await fs.mkdir(fullPath, { recursive: true });
+        return `文件夹创建成功: ${folderPath}`;
+    }
+    async function fullTextSearch(keyword) {
+        const files = await glob("**/*.md", {
+            cwd: vaultPath,
+            ignore: [".obsidian/**", ".smart-env/**", ".windsurf/**"],
+        });
+        const results = [];
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(path.join(vaultPath, file), "utf-8");
+                const lines = content.split("\n");
+                const matches = [];
+                lines.forEach((line, index) => {
+                    if (line.toLowerCase().includes(keyword.toLowerCase())) {
+                        matches.push(`L${index + 1}: ${line.trim().substring(0, 100)}`);
+                    }
+                });
+                if (matches.length > 0) {
+                    results.push({ path: file, matches: matches.slice(0, 5) });
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        return results.slice(0, 20);
+    }
+    async function moveNote(oldPath, newPath) {
+        const fullOldPath = path.join(vaultPath, oldPath);
+        const fullNewPath = path.join(vaultPath, newPath);
+        try {
+            await fs.access(fullOldPath);
+        }
+        catch {
+            throw new Error(`原笔记不存在: ${oldPath}`);
+        }
+        const dir = path.dirname(fullNewPath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.rename(fullOldPath, fullNewPath);
+        return `笔记已移动: ${oldPath} -> ${newPath}`;
+    }
+    async function getTemplate(templateName) {
+        const templatePath = path.join(vaultPath, "Obsidian-体系", "Templates", `${templateName}模板.md`);
+        try {
+            return await fs.readFile(templatePath, "utf-8");
+        }
+        catch {
+            throw new Error(`模板不存在: ${templateName}`);
+        }
+    }
+    return {
+        searchNotes,
+        readNote,
+        listFolder,
+        getNoteStructure,
+        createNote,
+        updateNote,
+        deleteNote,
+        createFolder,
+        fullTextSearch,
+        moveNote,
+        getTemplate,
+    };
+}

package/dist/services/prompt.d.ts

@@ -0,0 +1,3 @@
+export declare function suggestFolder(category: string): string;
+export declare function fillTemplate(template: string, data: Record<string, string>): string;
+export declare function getPromptGuide(): Promise<string>;

package/dist/services/prompt.js

@@ -0,0 +1,159 @@
+const vaultConventions = `# Obsidian 知识库体系化写作规范
+
+## 1. 核心目标
+构建一个“高内聚、低耦合、自生长”的知识网络。
+- **高内聚**：单一笔记只讲一个原子概念。
+- **低耦合**：通过双向链接 [[笔记名称]] 建立关系，而非死板的文件夹层级。
+- **自生长**：通过“问题链”驱动深度思考，通过“本质拆解”直击底层规律。
+
+---
+
+## 2. 笔记类型定义 (Type Specification)
+必须在 Frontmatter 的 \`type\` 字段中明确指定以下类型之一：
+
+| 类型 (Type) | 核心用途 | 结构要求 |
+| :--- | :--- | :--- |
+| **概念卡** | 原子化的知识点、术语、工具 | 定义、要点、本质视角、反例、应用、关联链接 |
+| **读书笔记** | 书籍、文章、课程的深度解析 | SQ3R框架、关键观点、原始来源、启发行动 |
+| **问题链** | 驱动思考的连续提问 | 关键问题清单、逻辑推理链 (前提→推理→结论) |
+| **本质拆解** | 对现象的第一性原理分析 | 现象、要素拆解、底层事实、重构方案 |
+| **扩展思路** | 知识迁移、跨学科对比 | 对比视角、迁移路径、新假设 |
+| **灵感启发** | 瞬间的火花、感悟、想法 | 触发点、新观点、立即行动 |
+| **复盘行动** | 周期性总结、项目复盘 | 目标对照、收获、盲区、改进措施、Todo |
+
+---
+
+## 3. 存储与元数据规范 (Folder & Metadata)
+
+### 3.1 自动分类映射 (Folder Mapping)
+根据 \`category\` 字段，笔记应存放在以下对应路径：
+- \`frontend\`: 知识点/02-前端知识/
+- \`backend\`: 知识点/05-后端知识/
+- \`hardware\`: 知识点/03-硬件学习/
+- \`ai\`: 知识点/04-人工智能/
+- \`docker\`: 知识点/01-Docker/
+- \`devops\`: 知识点/00-闲置笔记/git/
+- \`linux\`: 知识点/00-闲置笔记/Liunx/
+- \`database\`: 知识点/00-闲置笔记/数据库/
+- \`server\`: 知识点/00-闲置笔记/服务器安装环境/
+- \`security\`: 知识点/密钥/
+- \`music\`: 乐理/
+- \`misc\`: 知识点/00-闲置笔记/
+
+### 3.2 标准 YAML Frontmatter
+\`\`\`yaml
+---
+type: <必填: 笔记类型>
+status: <draft | active | archived>
+created: YYYY-MM-DD
+category: <映射分类>
+tags: [标签1, 标签2]
+summary: <一句话总结内容本质>
+folder: <自动映射的路径>
+source: <来源URL或书名>
+---
+\`\`\`
+
+---
+
+## 4. 连接策略 (Linking Strategy)
+- **索引连接**：概念卡必须链接 \`[[索引-概念卡]]\`，问题链链接 \`[[索引-问题链]]\`。
+- **逻辑双链**：在文末设置 「🔗 Related Notes」 章节，推测 3-5 个逻辑关联的笔记。
+- **反向链接**：在解释一个概念时，尽量链接其上位概念或基础原理。
+
+---
+
+## 5. 写作风格约束 (Writing Style)
+- **去废话化**：删除所有礼貌用语、过渡段落。
+- **结构化优先**：大量使用列表、任务列表 (\`- [ ]\`)、代码块。
+- **代码规范**：代码块必须标注语言，且包含简短注释说明关键逻辑。
+- **命名规范**：使用“主题-子主题”或“序号-主题”格式，如 \`React-Hooks深度分析.md\`。
+`;
+const guideHeader = `# 🗂️ Obsidian 知识库整理助手 - 终极提示词指南
+
+## 1. 提示词角色定位
+你不仅是一个整理者，更是一个**知识架构师**。
+你的任务是接收凌乱的输入（聊天记录、网页摘录、随手记），通过**深度学习框架**将其转化为具有**体系感**的 Obsidian 笔记。
+
+---
+
+## 2. 如何将此规范集成到 LLM
+
+### 场景 A：作为“系统提示词” (推荐)
+如果你使用 Claude Artifacts, ChatGPT Custom Instructions 或 Windsurf/Cursor：
+1. 调用 \`get_prompt_guide\` 获取下方全文。
+2. 将 **“三、提示词全文”** 部分复制到 AI 的 System Prompt 或角色设定中。
+
+### 场景 B：作为 Obsidian 模板使用
+1. 在 Obsidian 中创建 \`Templates/AI整理助手.md\`。
+2. 粘贴提示词全文。
+3. 需要整理内容时，呼出模板并全选复制给 AI。
+
+---
+
+## 3. 提示词全文 (复制到 AI 角色设定)
+
+\`\`\`markdown
+# Role: Obsidian 知识库架构师
+
+## Task
+将用户输入的原始、杂乱内容，转化为符合严格规范的 Obsidian 笔记。
+
+## Rules & Constraints
+${vaultConventions}
+
+## Workflow
+1. **分析意图**：判断内容属于哪种笔记类型（概念卡/问题链等）。
+2. **提取本质**：识别核心关键词和底层原理。
+3. **结构化构建**：填充对应的模板结构，生成 Frontmatter。
+4. **建立链接**：自动推测并添加相关联的笔记双链。
+5. **归档决策**：根据 category 确定 folder 路径。
+
+---
+## Start Processing
+请直接输出整理后的 Markdown 源代码，严禁输出任何开场白或解释。
+\`\`\`
+
+---
+
+## 4. MCP 工具联动建议
+当 AI 生成内容后，建议按以下顺序调用 MCP 工具：
+1. **\`generate_from_template\`**: 使用对应模板生成文件。
+2. **\`auto_archive_note\`**: 确保文件存放在规范的路径。
+3. **\`search_notes\`**: 搜索 AI 建议的 \`Related Notes\`，验证链接是否已存在，若不存在则打上待创建标记。
+`;
+const CATEGORY_MAP = {
+    frontend: "知识点/02-前端知识/",
+    backend: "知识点/05-后端知识/",
+    hardware: "知识点/03-硬件学习/",
+    ai: "知识点/04-人工智能/",
+    docker: "知识点/01-Docker/",
+    devops: "知识点/00-闲置笔记/git/",
+    linux: "知识点/00-闲置笔记/Liunx/",
+    database: "知识点/00-闲置笔记/数据库/",
+    server: "知识点/00-闲置笔记/服务器安装环境/",
+    security: "知识点/密钥/",
+    music: "乐理/",
+    misc: "知识点/00-闲置笔记/",
+};
+export function suggestFolder(category) {
+    return CATEGORY_MAP[category.toLowerCase()] || CATEGORY_MAP["misc"];
+}
+export function fillTemplate(template, data) {
+    let result = template;
+    for (const [key, value] of Object.entries(data)) {
+        // 替换 {{key}}
+        result = result.replace(new RegExp(`{{${key}}}`, "g"), value);
+        // 同时也支持替换 <key>
+        result = result.replace(new RegExp(`<${key}>`, "g"), value);
+    }
+    // 自动填充日期
+    if (!data.date) {
+        const today = new Date().toISOString().split("T")[0];
+        result = result.replace(/{{date}}/g, today);
+    }
+    return result;
+}
+export async function getPromptGuide() {
+    return `${guideHeader}`;
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,210 @@
+export declare function buildTools(vaultPath: string): {
+    tools: ({
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                query: {
+                    type: string;
+                    description: string;
+                };
+                tag: {
+                    type: string;
+                    description: string;
+                };
+                category: {
+                    type: string;
+                    description: string;
+                };
+                path?: undefined;
+                folder?: undefined;
+                keyword?: undefined;
+                content?: undefined;
+                templateName?: undefined;
+                noteName?: undefined;
+                data?: undefined;
+            };
+            required?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                path: {
+                    type: string;
+                    description: string;
+                };
+                query?: undefined;
+                tag?: undefined;
+                category?: undefined;
+                folder?: undefined;
+                keyword?: undefined;
+                content?: undefined;
+                templateName?: undefined;
+                noteName?: undefined;
+                data?: undefined;
+            };
+            required: string[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                folder: {
+                    type: string;
+                    description: string;
+                };
+                query?: undefined;
+                tag?: undefined;
+                category?: undefined;
+                path?: undefined;
+                keyword?: undefined;
+                content?: undefined;
+                templateName?: undefined;
+                noteName?: undefined;
+                data?: undefined;
+            };
+            required?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                query?: undefined;
+                tag?: undefined;
+                category?: undefined;
+                path?: undefined;
+                folder?: undefined;
+                keyword?: undefined;
+                content?: undefined;
+                templateName?: undefined;
+                noteName?: undefined;
+                data?: undefined;
+            };
+            required?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                keyword: {
+                    type: string;
+                    description: string;
+                };
+                query?: undefined;
+                tag?: undefined;
+                category?: undefined;
+                path?: undefined;
+                folder?: undefined;
+                content?: undefined;
+                templateName?: undefined;
+                noteName?: undefined;
+                data?: undefined;
+            };
+            required: string[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                path: {
+                    type: string;
+                    description: string;
+                };
+                content: {
+                    type: string;
+                    description: string;
+                };
+                query?: undefined;
+                tag?: undefined;
+                category?: undefined;
+                folder?: undefined;
+                keyword?: undefined;
+                templateName?: undefined;
+                noteName?: undefined;
+                data?: undefined;
+            };
+            required: string[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                path: {
+                    type: string;
+                    description: string;
+                };
+                category: {
+                    type: string;
+                    description: string;
+                };
+                query?: undefined;
+                tag?: undefined;
+                folder?: undefined;
+                keyword?: undefined;
+                content?: undefined;
+                templateName?: undefined;
+                noteName?: undefined;
+                data?: undefined;
+            };
+            required: string[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                templateName: {
+                    type: string;
+                    description: string;
+                };
+                noteName: {
+                    type: string;
+                    description: string;
+                };
+                data: {
+                    type: string;
+                    description: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+                category: {
+                    type: string;
+                    description: string;
+                };
+                folder: {
+                    type: string;
+                    description: string;
+                };
+                query?: undefined;
+                tag?: undefined;
+                path?: undefined;
+                keyword?: undefined;
+                content?: undefined;
+            };
+            required: string[];
+        };
+    })[];
+    handleTool: (name: string, args?: Record<string, unknown>) => Promise<string | import("../services/notes.js").NoteMeta[] | {
+        folders: string[];
+        notes: import("../services/notes.js").NoteMeta[];
+    } | Record<string, any> | {
+        path: string;
+        matches: string[];
+    }[]>;
+};