@zsc-glitch/knowledge-keeper-mcp 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 小影 (zsc-glitch)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# Knowledge Keeper MCP Server
+
+> 智能知识管理的 Model Context Protocol 实现
+
+## 简介
+
+让 **knowledge-keeper** 可被 Claude Code、Cursor、Gemini CLI、Windsurf 等工具调用。
+
+## 安装
+
+```bash
+npm install @zsc-glitch/knowledge-keeper-mcp
+```
+
+## 使用
+
+### Claude Code
+
+```bash
+claude mcp add knowledge-keeper -- npx @zsc-glitch/knowledge-keeper-mcp
+```
+
+### Gemini CLI
+
+在配置中添加：
+```json
+{
+  "mcpServers": {
+    "knowledge-keeper": {
+      "command": "npx",
+      "args": ["@zsc-glitch/knowledge-keeper-mcp"]
+    }
+  }
+}
+```
+
+## MCP Tools
+
+| Tool | 功能 |
+|------|------|
+| `knowledge_save` | 保存知识点 |
+| `knowledge_search` | 搜索知识 |
+| `knowledge_get` | 获取单个知识点 |
+| `knowledge_update` | 更新知识点 |
+| `knowledge_delete` | 删除知识点 |
+| `knowledge_tags` | 列出标签 |
+
+## MCP Resources（计划）
+
+| Resource | URI | 说明 |
+|----------|-----|------|
+| 知识点 | `knowledge:///{id}` | 单个知识点内容 |
+| 标签索引 | `knowledge:///tags` | 所有标签 |
+| 类型目录 | `knowledge:///type/{type}` | 按类型列出 |
+
+## 开发
+
+```bash
+# 构建
+npm run build
+
+# 本地测试
+node dist/index.js
+```
+
+## License
+
+MIT
+
+---
+
+Made with 🧠 by [小影](https://github.com/zsc-glitch)

package/dist/core.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Knowledge Keeper Core
+ * 核心逻辑，不依赖 OpenClaw SDK，可被 MCP Server 复用
+ */
+export type KnowledgeType = "concept" | "decision" | "todo" | "note" | "project";
+export interface KnowledgePoint {
+    id: string;
+    type: KnowledgeType;
+    title: string;
+    content: string;
+    tags: string[];
+    links: string[];
+    created: string;
+    updated: string;
+    source: "conversation" | "manual" | "mcp";
+}
+export declare class KnowledgeError extends Error {
+    code: string;
+    details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
+}
+export declare function getVaultDir(): string;
+export declare function generateId(type: KnowledgeType): string;
+export declare function saveKnowledge(params: {
+    type: KnowledgeType;
+    title: string;
+    content: string;
+    tags?: string[];
+    links?: string[];
+}): Promise<KnowledgePoint>;
+export declare function searchKnowledge(params: {
+    query: string;
+    type?: KnowledgeType;
+    tags?: string[];
+    limit?: number;
+}): Promise<KnowledgePoint[]>;
+export declare function getKnowledge(id: string): Promise<KnowledgePoint | null>;
+export declare function updateKnowledge(id: string, params: {
+    title?: string;
+    content?: string;
+    tags?: string[];
+    appendTags?: string[];
+}): Promise<KnowledgePoint | null>;
+export declare function deleteKnowledge(id: string): Promise<boolean>;
+export declare function listTags(): Promise<Record<string, number>>;
+export declare function reviewKnowledge(params: {
+    period?: "today" | "week" | "month" | "all";
+    type?: KnowledgeType;
+}): Promise<{
+    stats: Record<KnowledgeType, number>;
+    recent: KnowledgePoint[];
+}>;

package/dist/core.js

@@ -0,0 +1,418 @@
+/**
+ * Knowledge Keeper Core
+ * 核心逻辑，不依赖 OpenClaw SDK，可被 MCP Server 复用
+ */
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+// 错误类型
+export class KnowledgeError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "KnowledgeError";
+    }
+}
+// 获取知识库目录
+export function getVaultDir() {
+    const dir = process.env.KNOWLEDGE_KEEPER_DIR || "~/.knowledge-vault";
+    return dir.replace("~", os.homedir());
+}
+// 生成知识点 ID（类型前缀 + 时间戳 + 随机）
+export function generateId(type) {
+    const prefix = {
+        concept: "kp-cp",
+        decision: "kp-dc",
+        todo: "kp-td",
+        note: "kp-nt",
+        project: "kp-pj",
+    };
+    const timestamp = Date.now().toString(36);
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `${prefix[type]}-${timestamp}-${rand}`;
+}
+// 确保目录存在
+async function ensureDir(dir) {
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch (err) {
+        if (err.code !== "EEXIST") {
+            throw new KnowledgeError(`无法创建目录: ${dir}`, "DIR_CREATE_FAILED", { dir, error: err });
+        }
+    }
+}
+// 获取类型对应的子目录
+function getTypeDir(type) {
+    const dirs = {
+        concept: "concepts",
+        decision: "decisions",
+        todo: "todos",
+        note: "notes",
+        project: "projects",
+    };
+    return dirs[type];
+}
+// 从 ID 解析类型
+function parseTypeFromId(id) {
+    const prefix = id.slice(0, 5);
+    const map = {
+        "kp-cp": "concept",
+        "kp-dc": "decision",
+        "kp-td": "todo",
+        "kp-nt": "note",
+        "kp-pj": "project",
+    };
+    return map[prefix] || null;
+}
+// 格式化知识点为 Markdown
+function formatMarkdown(kp) {
+    return `---
+id: ${kp.id}
+type: ${kp.type}
+title: ${kp.title.replace(/\n/g, " ")}
+tags: [${kp.tags.join(", ")}]
+links: [${(kp.links || []).join(", ")}]
+created: ${kp.created}
+updated: ${kp.updated}
+source: ${kp.source}
+---
+
+# ${kp.title}
+
+${kp.content}
+`;
+}
+// 解析 Markdown 为知识点
+function parseMarkdown(content, filepath) {
+    try {
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (!frontmatterMatch)
+            return null;
+        const [, frontmatter, body] = frontmatterMatch;
+        const lines = frontmatter.split("\n");
+        const meta = {};
+        for (const line of lines) {
+            const colonIndex = line.indexOf(":");
+            if (colonIndex > 0) {
+                const key = line.slice(0, colonIndex).trim();
+                const value = line.slice(colonIndex + 1).trim();
+                meta[key] = value;
+            }
+        }
+        const titleMatch = body.match(/^#\s+(.+)$/m);
+        const title = titleMatch ? titleMatch[1].trim() : "Untitled";
+        const contentWithoutTitle = body.replace(/^#\s+.+\n/, "").trim();
+        const tagsMatch = meta.tags?.match(/\[([^\]]*)\]/);
+        const tags = tagsMatch ? tagsMatch[1].split(",").map((t) => t.trim()).filter(Boolean) : [];
+        const linksMatch = meta.links?.match(/\[([^\]]*)\]/);
+        const links = linksMatch ? linksMatch[1].split(",").map((l) => l.trim()).filter(Boolean) : [];
+        return {
+            id: meta.id || generateId(meta.type || "note"),
+            type: meta.type || "note",
+            title,
+            content: contentWithoutTitle,
+            tags,
+            links,
+            created: meta.created || new Date().toISOString(),
+            updated: meta.updated || new Date().toISOString(),
+            source: meta.source || "manual",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// 通过 ID 查找知识点文件路径
+async function findKnowledgeFile(vaultDir, id) {
+    // 尝试从 ID 解析类型
+    const type = parseTypeFromId(id);
+    if (type) {
+        const typeDir = path.join(vaultDir, getTypeDir(type));
+        const filepath = path.join(typeDir, `${id}.md`);
+        try {
+            await fs.access(filepath);
+            return filepath;
+        }
+        catch {
+            return null;
+        }
+    }
+    // 兼容旧 ID 格式：遍历所有类型
+    const types = ["concept", "decision", "todo", "note", "project"];
+    for (const t of types) {
+        const typeDir = path.join(vaultDir, getTypeDir(t));
+        const filepath = path.join(typeDir, `${id}.md`);
+        try {
+            await fs.access(filepath);
+            return filepath;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+// 加载索引
+async function loadIndex(vaultDir) {
+    const indexPath = path.join(vaultDir, "index.json");
+    try {
+        const content = await fs.readFile(indexPath, "utf-8");
+        const parsed = JSON.parse(content);
+        return {
+            version: parsed.version || 1,
+            entries: parsed.entries || [],
+            tagsIndex: parsed.tagsIndex || {},
+        };
+    }
+    catch {
+        return { version: 1, entries: [], tagsIndex: {} };
+    }
+}
+// 更新索引
+async function updateIndex(vaultDir, kp, mode = "add") {
+    const index = await loadIndex(vaultDir);
+    if (mode === "add") {
+        index.entries.push(kp);
+        for (const tag of kp.tags) {
+            if (!index.tagsIndex[tag])
+                index.tagsIndex[tag] = [];
+            if (!index.tagsIndex[tag].includes(kp.id))
+                index.tagsIndex[tag].push(kp.id);
+        }
+    }
+    else if (mode === "remove") {
+        const removed = index.entries.find((e) => e.id === kp.id);
+        index.entries = index.entries.filter((e) => e.id !== kp.id);
+        if (removed) {
+            for (const tag of removed.tags) {
+                if (index.tagsIndex[tag]) {
+                    index.tagsIndex[tag] = index.tagsIndex[tag].filter((id) => id !== kp.id);
+                    if (index.tagsIndex[tag].length === 0)
+                        delete index.tagsIndex[tag];
+                }
+            }
+        }
+    }
+    else if (mode === "update") {
+        const idx = index.entries.findIndex((e) => e.id === kp.id);
+        const oldKp = idx >= 0 ? index.entries[idx] : null;
+        if (idx >= 0) {
+            index.entries[idx] = kp;
+        }
+        else {
+            index.entries.push(kp);
+        }
+        // 更新标签索引
+        if (oldKp) {
+            for (const tag of oldKp.tags) {
+                if (!kp.tags.includes(tag) && index.tagsIndex[tag]) {
+                    index.tagsIndex[tag] = index.tagsIndex[tag].filter((id) => id !== kp.id);
+                    if (index.tagsIndex[tag].length === 0)
+                        delete index.tagsIndex[tag];
+                }
+            }
+        }
+        for (const tag of kp.tags) {
+            if (!index.tagsIndex[tag])
+                index.tagsIndex[tag] = [];
+            if (!index.tagsIndex[tag].includes(kp.id))
+                index.tagsIndex[tag].push(kp.id);
+        }
+    }
+    const indexPath = path.join(vaultDir, "index.json");
+    const tmpPath = path.join(vaultDir, "index.json.tmp");
+    await fs.writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
+    await fs.rename(tmpPath, indexPath);
+}
+// ==================== 公开 API ====================
+// 保存知识点
+export async function saveKnowledge(params) {
+    const vaultDir = getVaultDir();
+    const typeDir = getTypeDir(params.type);
+    const targetDir = path.join(vaultDir, typeDir);
+    await ensureDir(targetDir);
+    const kp = {
+        id: generateId(params.type),
+        type: params.type,
+        title: params.title,
+        content: params.content,
+        tags: params.tags || [],
+        links: params.links || [],
+        created: new Date().toISOString(),
+        updated: new Date().toISOString(),
+        source: "mcp",
+    };
+    const filepath = path.join(targetDir, `${kp.id}.md`);
+    await fs.writeFile(filepath, formatMarkdown(kp), "utf-8");
+    await updateIndex(vaultDir, kp, "add");
+    return kp;
+}
+// 搜索知识点
+export async function searchKnowledge(params) {
+    const vaultDir = getVaultDir();
+    const index = await loadIndex(vaultDir);
+    const limit = Math.min(params.limit || 10, 50);
+    const results = [];
+    // 筛选候选 ID
+    let candidateIds = null;
+    if (params.tags && params.tags.length > 0) {
+        for (const tag of params.tags) {
+            const tagLower = tag.toLowerCase();
+            const matchingIds = Object.entries(index.tagsIndex)
+                .filter(([t]) => t.toLowerCase().includes(tagLower))
+                .flatMap(([, ids]) => ids);
+            const idSet = new Set(matchingIds);
+            if (candidateIds === null) {
+                candidateIds = idSet;
+            }
+            else {
+                const existingIds = [...candidateIds];
+                candidateIds = new Set(existingIds.filter((id) => idSet.has(id)));
+            }
+        }
+    }
+    // 确定搜索范围
+    const types = params.type ? [params.type] : ["concept", "decision", "todo", "note", "project"];
+    for (const type of types) {
+        const typeDir = path.join(vaultDir, getTypeDir(type));
+        try {
+            const files = await fs.readdir(typeDir);
+            for (const file of files) {
+                if (!file.endsWith(".md"))
+                    continue;
+                const id = file.replace(/\.md$/, "");
+                if (candidateIds !== null && !candidateIds.has(id))
+                    continue;
+                const filepath = path.join(typeDir, file);
+                const content = await fs.readFile(filepath, "utf-8");
+                const kp = parseMarkdown(content, filepath);
+                if (!kp)
+                    continue;
+                const queryLower = params.query.toLowerCase();
+                const matchesQuery = kp.title.toLowerCase().includes(queryLower) || kp.content.toLowerCase().includes(queryLower);
+                const matchesTags = !params.tags ||
+                    params.tags.every((tag) => kp.tags.some((t) => t.toLowerCase().includes(tag.toLowerCase())));
+                if (matchesQuery && matchesTags) {
+                    results.push(kp);
+                    if (results.length >= limit)
+                        break;
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+        if (results.length >= limit)
+            break;
+    }
+    return results;
+}
+// 获取单个知识点
+export async function getKnowledge(id) {
+    const vaultDir = getVaultDir();
+    const filepath = await findKnowledgeFile(vaultDir, id);
+    if (!filepath)
+        return null;
+    const content = await fs.readFile(filepath, "utf-8");
+    return parseMarkdown(content, filepath);
+}
+// 更新知识点
+export async function updateKnowledge(id, params) {
+    const vaultDir = getVaultDir();
+    const filepath = await findKnowledgeFile(vaultDir, id);
+    if (!filepath)
+        return null;
+    const content = await fs.readFile(filepath, "utf-8");
+    const kp = parseMarkdown(content, filepath);
+    if (!kp)
+        return null;
+    if (params.title)
+        kp.title = params.title;
+    if (params.content)
+        kp.content = params.content;
+    if (params.tags) {
+        kp.tags = params.tags;
+    }
+    else if (params.appendTags) {
+        kp.tags = [...new Set([...kp.tags, ...params.appendTags])];
+    }
+    kp.updated = new Date().toISOString();
+    await fs.writeFile(filepath, formatMarkdown(kp), "utf-8");
+    await updateIndex(vaultDir, kp, "update");
+    return kp;
+}
+// 删除知识点
+export async function deleteKnowledge(id) {
+    const vaultDir = getVaultDir();
+    const filepath = await findKnowledgeFile(vaultDir, id);
+    if (!filepath)
+        return false;
+    const content = await fs.readFile(filepath, "utf-8");
+    const kp = parseMarkdown(content, filepath);
+    if (!kp)
+        return false;
+    await fs.unlink(filepath);
+    await updateIndex(vaultDir, kp, "remove");
+    return true;
+}
+// 列出所有标签
+export async function listTags() {
+    const vaultDir = getVaultDir();
+    const index = await loadIndex(vaultDir);
+    const tagsWithCount = {};
+    for (const [tag, ids] of Object.entries(index.tagsIndex)) {
+        tagsWithCount[tag] = ids.length;
+    }
+    return tagsWithCount;
+}
+// 回顾知识点
+export async function reviewKnowledge(params) {
+    const vaultDir = getVaultDir();
+    const period = params.period || "week";
+    const now = new Date();
+    let startDate;
+    switch (period) {
+        case "today":
+            startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+            break;
+        case "week":
+            startDate = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case "month":
+            startDate = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+            break;
+        default:
+            startDate = new Date(0);
+    }
+    const types = params.type ? [params.type] : ["concept", "decision", "todo", "note", "project"];
+    const results = [];
+    for (const type of types) {
+        const typeDir = path.join(vaultDir, getTypeDir(type));
+        try {
+            const files = await fs.readdir(typeDir);
+            for (const file of files) {
+                if (!file.endsWith(".md"))
+                    continue;
+                const filepath = path.join(typeDir, file);
+                const content = await fs.readFile(filepath, "utf-8");
+                const kp = parseMarkdown(content, filepath);
+                if (kp && new Date(kp.created) >= startDate) {
+                    results.push(kp);
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    results.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+    const stats = { concept: 0, decision: 0, todo: 0, note: 0, project: 0 };
+    for (const kp of results)
+        stats[kp.type]++;
+    return { stats, recent: results.slice(0, 10) };
+}
+//# sourceMappingURL=core.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Knowledge Keeper MCP Server
+ * MCP 实现 - 让 knowledge-keeper 可被 Claude Code、Cursor、Gemini CLI 等调用
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * Knowledge Keeper MCP Server
+ * MCP 实现 - 让 knowledge-keeper 可被 Claude Code、Cursor、Gemini CLI 等调用
+ */
+import { McpServer, StdioServerTransport } from "@modelcontextprotocol/server";
+import { registerTools } from "./tools/index.js";
+import { registerResources } from "./resources/index.js";
+// MCP Server 配置
+const server = new McpServer({
+    name: "knowledge-keeper",
+    version: "0.1.0-alpha.1",
+});
+// 注册 Tools
+registerTools(server);
+// 注册 Resources
+registerResources(server);
+// STDIO 传输（本地优先）
+const transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map

package/dist/resources/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * MCP Resources 注册
+ */
+import type { McpServer } from "@modelcontextprotocol/server";
+export declare function registerResources(server: McpServer): void;

package/dist/resources/index.js

@@ -0,0 +1,10 @@
+/**
+ * MCP Resources 注册
+ */
+export function registerResources(server) {
+    // TODO: 实现 Resources
+    // knowledge:///{id} - 单个知识点
+    // knowledge:///tags - 标签索引
+    // knowledge:///type/{type} - 按类型列出
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/delete.d.ts

@@ -0,0 +1,5 @@
+/**
+ * knowledge_delete MCP Tool
+ */
+import type { McpServer } from "@modelcontextprotocol/server";
+export declare function registerDeleteTool(server: McpServer): void;

package/dist/tools/delete.js

@@ -0,0 +1,47 @@
+/**
+ * knowledge_delete MCP Tool
+ */
+import { z } from "zod";
+import { deleteKnowledge } from "../core.js";
+export function registerDeleteTool(server) {
+    server.registerTool("knowledge_delete", {
+        title: "删除知识点",
+        description: "删除指定知识点",
+        inputSchema: z.object({
+            id: z.string().describe("要删除的知识点 ID"),
+        }),
+    }, async (params) => {
+        try {
+            const deleted = await deleteKnowledge(params.id);
+            if (!deleted) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ 未找到知识点: ${params.id}`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `🗑️ 已删除知识点\n\nID: ${params.id}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ 删除失败: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+}
+//# sourceMappingURL=delete.js.map

package/dist/tools/get.d.ts

@@ -0,0 +1,5 @@
+/**
+ * knowledge_get MCP Tool
+ */
+import type { McpServer } from "@modelcontextprotocol/server";
+export declare function registerGetTool(server: McpServer): void;

package/dist/tools/get.js

@@ -0,0 +1,47 @@
+/**
+ * knowledge_get MCP Tool
+ */
+import { z } from "zod";
+import { getKnowledge } from "../core.js";
+export function registerGetTool(server) {
+    server.registerTool("knowledge_get", {
+        title: "获取知识点",
+        description: "根据 ID 获取单个知识点",
+        inputSchema: z.object({
+            id: z.string().describe("知识点 ID"),
+        }),
+    }, async (params) => {
+        try {
+            const kp = await getKnowledge(params.id);
+            if (!kp) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ 未找到知识点: ${params.id}`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `📝 **${kp.title}**\n\n类型: ${kp.type}\nID: ${kp.id}\n创建: ${new Date(kp.created).toLocaleString("zh-CN")}\n标签: ${kp.tags.join(", ") || "无"}\n\n---\n\n${kp.content}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ 获取失败: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+}
+//# sourceMappingURL=get.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * MCP Tools 注册
+ */
+import type { McpServer } from "@modelcontextprotocol/server";
+export declare function registerTools(server: McpServer): void;

package/dist/tools/index.js

@@ -0,0 +1,18 @@
+/**
+ * MCP Tools 注册
+ */
+import { registerSaveTool } from "./save.js";
+import { registerSearchTool } from "./search.js";
+import { registerGetTool } from "./get.js";
+import { registerUpdateTool } from "./update.js";
+import { registerDeleteTool } from "./delete.js";
+import { registerTagsTool } from "./tags.js";
+export function registerTools(server) {
+    registerSaveTool(server);
+    registerSearchTool(server);
+    registerGetTool(server);
+    registerUpdateTool(server);
+    registerDeleteTool(server);
+    registerTagsTool(server);
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/save.d.ts

@@ -0,0 +1,5 @@
+/**
+ * knowledge_save MCP Tool
+ */
+import type { McpServer } from "@modelcontextprotocol/server";
+export declare function registerSaveTool(server: McpServer): void;

package/dist/tools/save.js

@@ -0,0 +1,45 @@
+/**
+ * knowledge_save MCP Tool
+ */
+import { z } from "zod";
+import { saveKnowledge } from "../core.js";
+export function registerSaveTool(server) {
+    server.registerTool("knowledge_save", {
+        title: "保存知识点",
+        description: "保存一条新的知识到知识库",
+        inputSchema: z.object({
+            type: z.enum(["concept", "decision", "todo", "note", "project"]).describe("知识类型"),
+            title: z.string().describe("标题"),
+            content: z.string().describe("内容"),
+            tags: z.array(z.string()).optional().describe("标签列表"),
+        }),
+    }, async (params) => {
+        try {
+            const kp = await saveKnowledge({
+                type: params.type,
+                title: params.title,
+                content: params.content,
+                tags: params.tags,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ 知识已保存\n\n📝 **${kp.title}**\n类型: ${kp.type}\nID: ${kp.id}\n标签: ${kp.tags.join(", ") || "无"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ 保存失败: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+}
+//# sourceMappingURL=save.js.map

package/dist/tools/search.d.ts

@@ -0,0 +1,5 @@
+/**
+ * knowledge_search MCP Tool
+ */
+import type { McpServer } from "@modelcontextprotocol/server";
+export declare function registerSearchTool(server: McpServer): void;

package/dist/tools/search.js

@@ -0,0 +1,58 @@
+/**
+ * knowledge_search MCP Tool
+ */
+import { z } from "zod";
+import { searchKnowledge } from "../core.js";
+export function registerSearchTool(server) {
+    server.registerTool("knowledge_search", {
+        title: "搜索知识",
+        description: "在知识库中搜索知识点",
+        inputSchema: z.object({
+            query: z.string().describe("搜索关键词"),
+            type: z.enum(["concept", "decision", "todo", "note", "project"]).optional().describe("筛选类型"),
+            tags: z.array(z.string()).optional().describe("筛选标签"),
+            limit: z.number().optional().describe("返回数量限制"),
+        }),
+    }, async (params) => {
+        try {
+            const results = await searchKnowledge({
+                query: params.query,
+                type: params.type,
+                tags: params.tags,
+                limit: params.limit,
+            });
+            if (results.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🔍 搜索: "${params.query}"\n\n未找到匹配的知识点`,
+                        },
+                    ],
+                };
+            }
+            const resultText = results
+                .map((kp, i) => `${i + 1}. **${kp.title}** (${kp.type})\n   ID: ${kp.id}\n   ${kp.content.slice(0, 100)}${kp.content.length > 100 ? "..." : ""}\n   标签: ${kp.tags.join(", ") || "无"}`)
+                .join("\n\n");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `🔍 找到 ${results.length} 条知识点\n\n${resultText}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ 搜索失败: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+}
+//# sourceMappingURL=search.js.map

package/dist/tools/tags.d.ts

@@ -0,0 +1,5 @@
+/**
+ * knowledge_tags MCP Tool
+ */
+import type { McpServer } from "@modelcontextprotocol/server";
+export declare function registerTagsTool(server: McpServer): void;

package/dist/tools/tags.js

@@ -0,0 +1,47 @@
+/**
+ * knowledge_tags MCP Tool
+ */
+import { z } from "zod";
+import { listTags } from "../core.js";
+export function registerTagsTool(server) {
+    server.registerTool("knowledge_tags", {
+        title: "列出标签",
+        description: "列出知识库中的所有标签",
+        inputSchema: z.object({}),
+    }, async () => {
+        try {
+            const tags = await listTags();
+            const entries = Object.entries(tags).sort((a, b) => b[1] - a[1]);
+            if (entries.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "🏷️ 知识库标签\n\n暂无标签",
+                        },
+                    ],
+                };
+            }
+            const tagsText = entries.map(([tag, count]) => `- **${tag}** (${count} 条)`).join("\n");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `🏷️ 知识库标签 (${entries.length} 个)\n\n${tagsText}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ 获取标签失败: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+}
+//# sourceMappingURL=tags.js.map

package/dist/tools/update.d.ts

@@ -0,0 +1,5 @@
+/**
+ * knowledge_update MCP Tool
+ */
+import type { McpServer } from "@modelcontextprotocol/server";
+export declare function registerUpdateTool(server: McpServer): void;

package/dist/tools/update.js

@@ -0,0 +1,56 @@
+/**
+ * knowledge_update MCP Tool
+ */
+import { z } from "zod";
+import { updateKnowledge } from "../core.js";
+export function registerUpdateTool(server) {
+    server.registerTool("knowledge_update", {
+        title: "更新知识点",
+        description: "更新现有知识点的内容或标签",
+        inputSchema: z.object({
+            id: z.string().describe("知识点 ID"),
+            title: z.string().optional().describe("新标题"),
+            content: z.string().optional().describe("新内容"),
+            tags: z.array(z.string()).optional().describe("新标签列表"),
+            appendTags: z.array(z.string()).optional().describe("追加标签"),
+        }),
+    }, async (params) => {
+        try {
+            const kp = await updateKnowledge(params.id, {
+                title: params.title,
+                content: params.content,
+                tags: params.tags,
+                appendTags: params.appendTags,
+            });
+            if (!kp) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ 未找到知识点: ${params.id}`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ 知识已更新\n\n📝 **${kp.title}**\nID: ${kp.id}\n标签: ${kp.tags.join(", ") || "无"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ 更新失败: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+}
+//# sourceMappingURL=update.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@zsc-glitch/knowledge-keeper-mcp",
+  "version": "0.1.0-alpha.1",
+  "description": "MCP Server for Knowledge Keeper - 智能知识管理的 Model Context Protocol 实现",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "knowledge-keeper-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && sed -i '1i#!/usr/bin/env node' dist/index.js",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "memory",
+    "knowledge",
+    "ai",
+    "claude-code",
+    "openclaw"
+  ],
+  "author": "小影 <zsc-glitch>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zsc-glitch/knowledge-keeper-mcp"
+  },
+  "dependencies": {
+    "@cfworker/json-schema": "^4.1.1",
+    "@modelcontextprotocol/server": "2.0.0-alpha.2",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.17",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}