@linkmind_claw/openclaw-faq-kb 2.0.3 → 3.1.0

package/dist/index.js

@@ -1,18 +1,13 @@
 /**
- * OpenClaw Plugin — LinkMind Knowledge Base
+ * OpenClaw Plugin entry — FAQ Knowledge Base
  *
- * 一个 OpenClaw 实例 = 一个管理员（Owner）
- * 管理员通过 /linkmind_claim 绑定身份，拥有全部管理权限
- * 其他用户只能查询被开放的知识库
+ * 5 tools + 5 slash commands:
  *
- * Slash Commands:
- *   /linkmind_help    — 使用帮助
- *   /linkmind_claim   — 绑定管理员身份
- *   /linkmind_me      — 查看我的身份信息
- *   /linkmind_create  — 创建知识库并训练（仅 Owner）
- *   /linkmind_query   — 知识库问答
- *   /linkmind_share   — 管理 KB 权限（仅 Owner）
- *   /linkmind_list    — 列出可访问的知识库
+ *   1. faq_account_register     — channel user auto-register / login
+ *   2. faq_account_manage       — grant roles, list users, view my info
+ *   3. faq_kb_create_and_train  — one-click: create KB + auto-pipeline
+ *   4. faq_kb_query             — intelligent Q&A
+ *   5. faq_kb_list              — list accessible knowledge bases
  */
 import { Type } from "@sinclair/typebox";
 import { FaqKbApiClient } from "./lib/api-client.js";
@@ -26,144 +21,81 @@ function definePluginEntry(entry) {
 // ── Export ─────────────────────────────────────────────────────────────
 export default definePluginEntry({
     id: "faq-knowledge-base",
-    name: "LinkMind Knowledge Base",
-    description: "LinkMind 智能知识库：管理员绑定、一键上传文档训练、智能问答",
+    name: "FAQ Knowledge Base",
+    description: "FAQ 知识库插件：社媒用户自动注册、权限管理、一键建库训练、智能问答",
     register(api) {
         const cfg = (api.pluginConfig ?? {});
         const baseUrl = cfg.apiBaseUrl || "http://67.212.146.21:8999";
         const pollInterval = cfg.pollIntervalMs ?? 8_000;
         const pipelineTimeout = cfg.pipelineTimeoutMs ?? 20 * 60 * 1000;
+        const defaultBotId = cfg.defaultBotId ?? "default";
         const client = new FaqKbApiClient({
             baseUrl,
             staticToken: cfg.apiToken || undefined,
         });
-        let cachedOwnerStatus = null;
-        async function getOwnerStatus() {
-            if (cachedOwnerStatus && cachedOwnerStatus.claimed && Date.now() - cachedOwnerStatus.checkedAt < 60_000) {
-                return { claimed: true, owner_telegram_id: null };
-            }
-            try {
-                const res = await client.get("/owner/status");
-                const data = res.data ?? res;
-                cachedOwnerStatus = { claimed: !!data.claimed, checkedAt: Date.now() };
-                return data;
-            }
-            catch {
-                return { claimed: false, owner_telegram_id: null };
-            }
-        }
-        async function ensureAuth(ctx) {
-            if (!ctx.senderId || !ctx.channel) {
-                return "无法获取你的用户信息，请在社媒渠道中使用。";
-            }
-            const status = await getOwnerStatus();
-            if (!status.claimed) {
-                const secret = status.claim_secret;
-                if (secret) {
-                    return [
-                        "🎉 欢迎使用 LinkMind！此服务器尚未绑定管理员。",
-                        "你是第一个使用此 Bot 的用户，可以直接激活管理员身份！",
-                        "",
-                        "请发送以下命令完成绑定：",
-                        `  /linkmind_claim ${secret}`,
-                        "",
-                        "绑定后你将拥有完整的知识库管理权限。",
-                    ].join("\n");
-                }
-                return [
-                    "此服务器尚未绑定管理员。",
-                    "如果你是部署者，请使用以下命令完成绑定：",
-                    "  /linkmind_claim <部署时生成的密钥>",
-                    "密钥可在服务器启动日志中找到。",
-                ].join("\n");
-            }
-            client.setSender(ctx.senderId);
-            if (client.hasUserToken(ctx.senderId)) {
-                return null;
-            }
-            try {
-                await client.oauthLogin({
-                    channel_type: ctx.channel,
-                    channel_user_id: ctx.senderId,
-                    display_name: "",
-                });
-                return null;
-            }
-            catch (e) {
-                return `⚠️ 自动登录失败: ${e.message}`;
-            }
-        }
-        async function requireOwner(ctx) {
-            const authErr = await ensureAuth(ctx);
-            if (authErr)
-                return authErr;
-            try {
-                const res = await client.get("/oauth/me");
-                const data = res.data ?? res;
-                if (!data.is_owner) {
-                    const status = await getOwnerStatus();
-                    if (!status.claimed && status.claim_secret) {
-                        return [
-                            "此服务器尚未绑定管理员。",
-                            "请先完成绑定：",
-                            `  /linkmind_claim ${status.claim_secret}`,
-                        ].join("\n");
-                    }
-                    return "此操作仅限管理员。如需查询知识库请使用 /linkmind_query";
-                }
-                return null;
-            }
-            catch {
-                return "无法验证管理员身份，请稍后再试。";
-            }
-        }
-        // ── Tools ──────────────────────────────────────────────────────────
+        // ── Tool 1: Account Register ─────────────────────────────────────
         api.registerTool({
-            name: "linkmind_account_register",
-            label: "用户注册/登录",
+            name: "faq_account_register",
+            label: "社媒用户注册/登录",
             description: [
-                "社媒用户 OAuth 注册或登录。",
-                "首次调用自动创建账号，后续调用等同登录。",
+                "社媒渠道用户自动注册或登录。",
+                "首次调用为指定渠道用户创建账号，后续调用返回已有身份。",
                 "支持 Telegram / Discord / Slack / Web 等渠道。",
+                "新用户默认角色为 viewer（只能查询），Owner 可通过 faq_account_manage 提升权限。",
+                "注册后 API Key 自动缓存，后续所有操作使用该用户身份鉴权。",
             ].join(" "),
             parameters: AccountRegisterParams,
             execute: (_id, params) => executeAccountRegister(client, params),
         });
+        // ── Tool 2: Account Manage ───────────────────────────────────────
         api.registerTool({
-            name: "linkmind_account_manage",
-            label: "权限管理",
+            name: "faq_account_manage",
+            label: "账号权限管理",
             description: [
-                "管理员权限操作工具。",
-                "grant_role / list_users / my_info",
+                "管理社媒渠道用户的权限和角色。需要 admin 权限。",
+                "grant_role: 给指定用户授权角色和知识库访问范围；",
+                "list_users: 列出所有已注册的渠道用户；",
+                "my_info: 查看当前用户的身份、角色和配额信息。",
             ].join(" "),
             parameters: AccountManageParams,
             execute: (_id, params) => executeAccountManage(client, params),
         });
+        // ── Tool 3: Create & Train ───────────────────────────────────────
         api.registerTool({
-            name: "linkmind_kb_create_and_train",
+            name: "faq_kb_create_and_train",
             label: "创建知识库并训练",
             description: [
-                "创建 FAQ 知识库并自动完成全部训练流程。",
-                "支持 PDF / DOCX / DOC / TXT / MD 格式。",
-                "训练过程通常需要 2-10 分钟。",
+                "创建一个新的 FAQ 知识库并自动完成全部训练流程。需要 editor 以上权限。",
+                "内部执行: 创建知识库 → 上传文档 → AI 提取 FAQ → 构建知识树 → 建索引。",
+                "训练完成后知识库即可用于问答（faq_kb_query）。",
+                "支持 PDF / DOCX / DOC / TXT / MD 格式，通过 file_url 传入文件地址。",
+                "训练过程通常需要 2-10 分钟，取决于文档大小。",
             ].join(" "),
             parameters: CreateAndTrainParams,
             execute: (_id, params) => executeCreateAndTrain(client, params, pollInterval, pipelineTimeout),
         });
+        // ── Tool 4: Query ────────────────────────────────────────────────
         api.registerTool({
-            name: "linkmind_kb_query",
+            name: "faq_kb_query",
             label: "知识库问答",
             description: [
-                "向知识库提问并获取 AI 智能回答。",
-                "可以用知识库名称(kb_name)或 ID(kb_id)指定，推荐用名称。",
+                "向指定知识库提问并获取 AI 智能回答。需要 viewer 以上权限。",
+                "知识库必须已经训练完成（is_active=true）。",
+                "设置 enable_polish=true 可让 LLM 综合多个 FAQ 生成更自然的回答。",
+                "返回包含答案、置信度、来源引用和日志 ID。",
             ].join(" "),
             parameters: QueryParams,
             execute: (_id, params) => executeQuery(client, params),
         });
+        // ── Tool 5: List KB ──────────────────────────────────────────────
         api.registerTool({
-            name: "linkmind_kb_list",
+            name: "faq_kb_list",
             label: "查看知识库列表",
-            description: "列出当前可访问的所有知识库。",
+            description: [
+                "列出当前可访问的所有知识库。需要 viewer 以上权限。",
+                "返回每个知识库的 ID、名称、标签和训练状态。",
+                "支持按名称和标签筛选，支持分页。",
+            ].join(" "),
             parameters: Type.Object({
                 keyword: Type.Optional(Type.String({ description: "按名称搜索（可选）" })),
                 tag_name: Type.Optional(Type.String({ description: "按标签筛选（可选）" })),
@@ -183,150 +115,95 @@ export default definePluginEntry({
                 const total = res.total ?? items.length;
                 const lines = [`知识库列表（共 ${total} 个）:`];
                 for (const kb of items) {
-                    const st = kb.is_active ? "就绪" : "未训练";
+                    const s = kb.is_active ? "就绪" : "未训练";
                     const tag = kb.tag_name ? ` [${kb.tag_name}]` : "";
-                    lines.push(`  ${kb.id}  ${kb.name}${tag}  (${st})`);
+                    lines.push(`  ${kb.id}  ${kb.name}${tag}  (${s})`);
                 }
                 if (items.length === 0)
                     lines.push("  (无知识库)");
                 return { content: [{ type: "text", text: lines.join("\n") }] };
             },
         });
-        // ── Slash Commands ─────────────────────────────────────────────────
+        // ══════════════════════════════════════════════════════════════════
+        // Slash Commands — 5 个，和 5 个 Tools 一一对应
+        // ══════════════════════════════════════════════════════════════════
+        // 1. /faq_register [channel_user_id] — 注册/登录
         api.registerCommand({
-            name: "linkmind_help",
-            description: "LinkMind 使用帮助",
+            name: "faq_register",
+            description: "注册/登录: /faq_register 或 /faq_register <渠道用户ID>",
+            acceptsArgs: true,
             handler: async (ctx) => {
-                const status = await getOwnerStatus();
-                let isOwner = false;
-                if (status.claimed && ctx.senderId && ctx.channel) {
-                    client.setSender(ctx.senderId);
-                    if (!client.hasUserToken(ctx.senderId)) {
-                        try {
-                            await client.oauthLogin({
-                                channel_type: ctx.channel,
-                                channel_user_id: ctx.senderId,
-                                display_name: "",
-                            });
-                        }
-                        catch { /* ignore */ }
-                    }
-                    try {
-                        const me = await client.get("/oauth/me");
-                        isOwner = !!(me.data ?? me).is_owner;
-                    }
-                    catch { /* ignore */ }
-                }
-                const lines = [
-                    "LinkMind 智能知识库",
-                    "━━━━━━━━━━━━━━━━━━",
-                ];
-                if (!status.claimed) {
-                    const secret = status.claim_secret;
-                    if (secret) {
-                        lines.push("", "🎉 此服务器尚未绑定管理员，你可以直接激活！", "", "请发送以下命令：", `  /linkmind_claim ${secret}`, "", "绑定后即可创建和管理知识库。");
+                const channelUserId = (ctx.args ?? "").trim() || ctx.senderId || "unknown";
+                const channelType = ctx.channel.includes("telegram") ? "telegram"
+                    : ctx.channel.includes("discord") ? "discord"
+                        : ctx.channel.includes("slack") ? "slack"
+                            : "web";
+                try {
+                    const res = await client.post("/auth/channel_register", {
+                        channel_type: channelType,
+                        channel_user_id: channelUserId,
+                        channel_bot_id: defaultBotId,
+                        display_name: "",
+                        role: "viewer",
+                    });
+                    if (!res.success)
+                        return { text: `注册失败: ${res.message}` };
+                    const d = res.data;
+                    if (d.api_key) {
+                        client.storeUserApiKey({ channelType, channelUserId, channelBotId: defaultBotId }, d.api_key);
                     }
-                    else {
-                        lines.push("", "首次使用？请先绑定管理员身份：", "  /linkmind_claim <密钥>", "", "密钥在服务器启动日志中生成。", "绑定后即可创建和管理知识库。");
+                    if (d.is_new) {
+                        return { text: `注册成功!\n  用户: ${d.name}\n  角色: ${d.role}\n  ID: ${d.user_id}\n\n你现在可以使用 /faq_list 查看知识库，/faq_query 进行问答。` };
                     }
+                    return { text: `欢迎回来!\n  用户: ${d.name}\n  角色: ${d.role}\n  ID: ${d.user_id}` };
                 }
-                else if (isOwner) {
-                    lines.push("", "你是管理员，可用命令:", "", "  /linkmind_create <名称> <文档URL>", "    创建知识库并自动训练", "    支持 PDF / DOCX / DOC / TXT / MD", "", "  /linkmind_list", "    查看所有知识库", "", "  /linkmind_query <知识库名称> <问题>", "    向知识库提问", "", "  /linkmind_share <KB名> <用户ID> <角色>", "    分享知识库给其他用户", "    角色: viewer / editor / revoke", "", "  /linkmind_me", "    查看你的身份信息");
-                }
-                else {
-                    lines.push("", "可用命令:", "", "  /linkmind_list", "    查看你可访问的知识库", "", "  /linkmind_query <知识库名称> <问题>", "    向知识库提问", "", "  /linkmind_me", "    查看你的身份信息");
+                catch (e) {
+                    return { text: `注册失败: ${e.message}` };
                 }
-                return { text: lines.join("\n") };
             },
         });
+        // 2. /faq_grant <channel_user_id> <role> — 授权
         api.registerCommand({
-            name: "linkmind_claim",
-            description: "绑定管理员身份: /linkmind_claim <密钥>",
+            name: "faq_grant",
+            description: "授权: /faq_grant <渠道用户ID> <角色>",
             acceptsArgs: true,
+            requireAuth: true,
             handler: async (ctx) => {
-                if (!ctx.senderId || !ctx.channel) {
-                    return { text: "无法获取你的用户信息，请在社媒渠道中使用。" };
-                }
-                const secret = (ctx.args ?? "").trim();
-                if (!secret) {
-                    return {
-                        text: [
-                            "用法: /linkmind_claim <密钥>",
-                            "",
-                            "密钥在首次对话时自动展示，或可在服务器启动日志中查看。",
-                            "绑定后你将成为此服务器的管理员，拥有创建/管理知识库的权限。",
-                        ].join("\n"),
-                    };
-                }
-                client.setSender(ctx.senderId);
-                if (!client.hasUserToken(ctx.senderId)) {
-                    try {
-                        await client.oauthLogin({
-                            channel_type: ctx.channel,
-                            channel_user_id: ctx.senderId,
-                            display_name: "",
-                        });
-                    }
-                    catch (e) {
-                        return { text: `⚠️ 登录失败: ${e.message}` };
-                    }
+                const parts = (ctx.args ?? "").trim().split(/\s+/);
+                if (parts.length < 2) {
+                    return { text: "用法: /faq_grant <渠道用户ID> <角色>\n角色: viewer / editor / reviewer / admin\n示例: /faq_grant 123456789 editor" };
                 }
+                const [targetId, role] = parts;
+                const channelType = ctx.channel.includes("telegram") ? "telegram"
+                    : ctx.channel.includes("discord") ? "discord"
+                        : "web";
                 try {
-                    const res = await client.post("/owner/claim", {
-                        claim_secret: secret,
+                    const res = await client.post("/auth/grant_role", {
+                        target_channel_user_id: targetId,
+                        target_channel_type: channelType,
+                        channel_bot_id: defaultBotId,
+                        role,
                     });
-                    cachedOwnerStatus = { claimed: true, checkedAt: Date.now() };
-                    return {
-                        text: [
-                            `✅ ${res.message || "绑定成功！"}`,
-                            "",
-                            "你现在是此服务器的管理员。",
-                            "输入 /linkmind_help 查看可用命令。",
-                        ].join("\n"),
-                    };
-                }
-                catch (e) {
-                    return { text: `❌ 绑定失败: ${e.message}` };
-                }
-            },
-        });
-        api.registerCommand({
-            name: "linkmind_me",
-            description: "查看我的身份信息",
-            handler: async (ctx) => {
-                const authErr = await ensureAuth(ctx);
-                if (authErr)
-                    return { text: authErr };
-                try {
-                    const res = await client.get("/oauth/me");
-                    const d = res.data ?? res;
-                    const ownerTag = d.is_owner ? " (管理员)" : "";
-                    const lines = [
-                        `✅ 你已登录${ownerTag}`,
-                        `  用户 ID: ${d.user_id ?? d.id ?? "—"}`,
-                        `  名称: ${d.name ?? "—"}`,
-                        `  角色: ${d.role ?? "—"}`,
-                        `  渠道: ${d.channel_type ?? "—"}`,
-                    ];
-                    return { text: lines.join("\n") };
+                    if (!res.success)
+                        return { text: `授权失败: ${res.message}` };
+                    const d = res.data;
+                    return { text: `授权成功!\n  用户: ${d.name}\n  角色变更: ${d.old_role} -> ${d.new_role}` };
                 }
                 catch (e) {
-                    return { text: `❌ 获取信息失败: ${e.message}` };
+                    return { text: `授权失败: ${e.message}` };
                 }
             },
         });
+        // 3. /faq_create <kb_name> <file_url>
         api.registerCommand({
-            name: "linkmind_create",
-            description: "创建知识库并训练（仅管理员）: /linkmind_create <名称> <文档URL>",
+            name: "faq_create",
+            description: "创建知识库并训练: /faq_create <名称> <文档URL>",
             acceptsArgs: true,
             handler: async (ctx) => {
-                const authErr = await requireOwner(ctx);
-                if (authErr)
-                    return { text: authErr };
                 const args = (ctx.args ?? "").trim();
                 const spaceIdx = args.indexOf(" ");
                 if (!args || spaceIdx === -1) {
-                    return { text: "用法: /linkmind_create <知识库名称> <文档URL>\n示例: /linkmind_create 客服知识库 https://example.com/doc.pdf\n支持 PDF/DOCX/DOC/TXT/MD" };
+                    return { text: "用法: /faq_create <知识库名称> <文档URL>\n示例: /faq_create 客服知识库 https://example.com/doc.pdf\n支持 PDF/DOCX/DOC/TXT/MD" };
                 }
                 const kbName = args.slice(0, spaceIdx).trim();
                 const fileUrl = args.slice(spaceIdx + 1).trim();
@@ -342,149 +219,616 @@ export default definePluginEntry({
                         name: kbName, description: "", file_path: fileUrl,
                     });
                     if (!pipeRes.success) {
-                        return { text: `❌ 启动训练失败: ${pipeRes.message}\n知识库已创建 (ID: ${kbId})` };
+                        return { text: `启动训练失败: ${pipeRes.message}\n知识库已创建 (ID: ${kbId})` };
                     }
-                    return { text: `🚀 知识库创建成功，训练已启动！\n  名称: ${kbName}\n  KB ID: ${kbId}\n  任务 ID: ${pipeRes.data.task_id}\n\n训练需要 2-10 分钟，完成后可用 /linkmind_query 提问。` };
+                    return { text: `知识库创建成功，训练已启动!\n  名称: ${kbName}\n  KB ID: ${kbId}\n  任务 ID: ${pipeRes.data.task_id}\n\n训练需要 2-10 分钟，完成后可用 /faq_query 提问。` };
                 }
                 catch (e) {
-                    return { text: `❌ 创建失败: ${e.message}` };
+                    return { text: `创建失败: ${e.message}` };
                 }
             },
         });
+        // 4. /faq_query <kb_id> <question>
         api.registerCommand({
-            name: "linkmind_query",
-            description: "知识库问答: /linkmind_query <知识库名称> <问题>",
+            name: "faq_query",
+            description: "知识库问答: /faq_query <kb_id> <问题>",
             acceptsArgs: true,
             handler: async (ctx) => {
-                const authErr = await ensureAuth(ctx);
-                if (authErr)
-                    return { text: authErr };
                 const args = (ctx.args ?? "").trim();
                 const spaceIdx = args.indexOf(" ");
                 if (!args || spaceIdx === -1) {
-                    return { text: "用法: /linkmind_query <知识库名称> <问题>\n示例: /linkmind_query 客服知识库 什么是退款政策？" };
+                    return { text: "用法: /faq_query <kb_id> <问题>\n示例: /faq_query abc123 什么是退款政策？" };
                 }
-                const nameOrId = args.slice(0, spaceIdx).trim();
+                const kbId = args.slice(0, spaceIdx).trim();
                 const question = args.slice(spaceIdx + 1).trim();
                 if (!question)
                     return { text: "请提供问题" };
                 try {
-                    let res;
-                    try {
-                        res = await client.post("/knowledge_bases/query_by_name", {
-                            kb_name: nameOrId, question, enable_polish: false,
-                        });
+                    const res = await client.post(`/knowledge_bases/${kbId}/query`, {
+                        question, enable_polish: false,
+                    });
+                    if (!res.success)
+                        return { text: `查询失败: ${res.message}` };
+                    const d = res.data;
+                    const lines = [d.answer || "(无答案)"];
+                    if (d.faq_data?.question)
+                        lines.push(`匹配: ${d.faq_data.question}`);
+                    if (d.source_nodes?.[0]?.score != null) {
+                        lines.push(`置信度: ${(d.source_nodes[0].score * 100).toFixed(1)}%`);
                     }
-                    catch {
-                        res = await client.post(`/knowledge_bases/${nameOrId}/query`, {
-                            question, enable_polish: false,
-                        });
+                    return { text: lines.join("\n") };
+                }
+                catch (e) {
+                    return { text: `问答失败: ${e.message}` };
+                }
+            },
+        });
+        // 5. /faq_list
+        api.registerCommand({
+            name: "faq_list",
+            description: "列出所有知识库",
+            handler: async () => {
+                try {
+                    const res = await client.get("/knowledge_bases?page=1&page_size=0");
+                    const items = res.items ?? res.data?.items ?? [];
+                    const total = res.total ?? items.length;
+                    const lines = [`知识库列表（共 ${total} 个）:`];
+                    for (const kb of items) {
+                        const st = kb.is_active ? "就绪" : "未训练";
+                        const tag = kb.tag_name ? ` [${kb.tag_name}]` : "";
+                        lines.push(`  ${kb.name}${tag}  ${st}\n    ID: ${kb.id}`);
+                    }
+                    if (items.length === 0)
+                        lines.push("  （暂无知识库）");
+                    return { text: lines.join("\n") };
+                }
+                catch (e) {
+                    return { text: `获取失败: ${e.message}` };
+                }
+            },
+        });
+        // 6. /linkmind_terms <kb_id> [pattern] — 查看/管理术语词典
+        api.registerCommand({
+            name: "linkmind_terms",
+            description: "术语词典: /linkmind_terms <kb_id> [搜索词]",
+            acceptsArgs: true,
+            handler: async (ctx) => {
+                const args = (ctx.args ?? "").trim();
+                if (!args) {
+                    return { text: "用法:\n  /linkmind_terms <kb_id>  — 查看所有术语映射\n  /linkmind_terms <kb_id> 异响  — 搜索包含\"异响\"的映射\n\n术语词典在建索引时自动从知识图谱生成，也可通过 API 手动管理。" };
+                }
+                const spaceIdx = args.indexOf(" ");
+                const kbId = spaceIdx > 0 ? args.slice(0, spaceIdx).trim() : args;
+                const searchTerm = spaceIdx > 0 ? args.slice(spaceIdx + 1).trim() : "";
+                try {
+                    const res = await client.get(`/knowledge_bases/${kbId}/terminology?config_type=synonym`);
+                    if (!res.success)
+                        return { text: `查询失败: ${res.message}` };
+                    let items = res.data?.items ?? [];
+                    if (searchTerm) {
+                        items = items.filter((i) => i.pattern.includes(searchTerm) || i.replacement.includes(searchTerm));
+                    }
+                    if (items.length === 0) {
+                        return { text: searchTerm ? `未找到包含 "${searchTerm}" 的术语映射` : "该知识库暂无术语映射" };
+                    }
+                    // Group by pattern
+                    const grouped = {};
+                    for (const item of items) {
+                        if (!grouped[item.pattern])
+                            grouped[item.pattern] = [];
+                        grouped[item.pattern].push(item.replacement);
+                    }
+                    const lines = [`术语词典（共 ${items.length} 条映射，${Object.keys(grouped).length} 个 pattern）:`];
+                    const entries = Object.entries(grouped).slice(0, 20);
+                    for (const [pattern, replacements] of entries) {
+                        lines.push(`  "${pattern}" → ${replacements.join(", ")}`);
+                    }
+                    if (Object.keys(grouped).length > 20) {
+                        lines.push(`  ... 还有 ${Object.keys(grouped).length - 20} 个`);
+                    }
+                    return { text: lines.join("\n") };
+                }
+                catch (e) {
+                    return { text: `查询失败: ${e.message}` };
+                }
+            },
+        });
+        // 7. /linkmind_graph <kb_id> [entity_name] — 查看知识图谱
+        api.registerCommand({
+            name: "linkmind_graph",
+            description: "知识图谱: /linkmind_graph <kb_id> [实体名]",
+            acceptsArgs: true,
+            handler: async (ctx) => {
+                const args = (ctx.args ?? "").trim();
+                if (!args) {
+                    return { text: "用法:\n  /linkmind_graph <kb_id>  — 查看图谱概览(实体/关系/FAQ映射统计)\n  /linkmind_graph <kb_id> Z7T  — 查看 Z7T 的关系和关联FAQ\n  /linkmind_graph <kb_id> 止回阀  — 查看止回阀的关系和关联FAQ" };
+                }
+                const spaceIdx = args.indexOf(" ");
+                const kbId = spaceIdx > 0 ? args.slice(0, spaceIdx).trim() : args;
+                const entityName = spaceIdx > 0 ? args.slice(spaceIdx + 1).trim() : "";
+                try {
+                    if (!entityName) {
+                        // Show graph stats overview
+                        const res = await client.get(`/knowledge_bases/${kbId}/graph/stats`);
+                        if (!res.success)
+                            return { text: `查询失败: ${res.message}` };
+                        const d = res.data ?? {};
+                        const lines = [`知识图谱概览:`];
+                        lines.push(`  实体总数: ${d.total_entities ?? 0}`);
+                        lines.push(`  关系总数: ${d.total_relations ?? 0}`);
+                        lines.push(`  FAQ-实体映射: ${d.faq_entity_mappings ?? 0}`);
+                        lines.push(`  已映射FAQ: ${d.mapped_faqs ?? 0}`);
+                        lines.push(`  已映射实体: ${d.mapped_entities ?? 0}`);
+                        lines.push(`\n实体类型分布:`);
+                        for (const [t, c] of Object.entries(d.entity_distribution ?? {})) {
+                            lines.push(`  ${t}: ${c}`);
+                        }
+                        lines.push(`\n关系类型分布:`);
+                        for (const [t, c] of Object.entries(d.relation_distribution ?? {})) {
+                            lines.push(`  ${t}: ${c}`);
+                        }
+                        lines.push("\n使用 /linkmind_graph <kb_id> <实体名> 查看该实体的关系和关联FAQ");
+                        return { text: lines.join("\n") };
+                    }
+                    // Show relations for specific entity
+                    const res = await client.get(`/knowledge_bases/${kbId}/graph/relations?entity=${encodeURIComponent(entityName)}`);
+                    if (!res.success)
+                        return { text: `查询失败: ${res.message}` };
+                    const items = res.data?.items ?? [];
+                    if (items.length === 0) {
+                        return { text: `未找到与 "${entityName}" 相关的关系` };
                     }
-                    if (!res.success) {
-                        const candidates = res.data?.candidates;
-                        if (candidates?.length) {
-                            const list = candidates.map((c) => `  • ${c.name} (${c.id})`).join("\n");
-                            return { text: `${res.message}\n\n可选:\n${list}` };
+                    const lines = [`"${entityName}" 的知识图谱关系（${items.length} 条）:`];
+                    // Group by predicate
+                    const byPred = {};
+                    for (const item of items) {
+                        const pred = item.predicate;
+                        if (!byPred[pred])
+                            byPred[pred] = [];
+                        byPred[pred].push(item);
+                    }
+                    for (const [pred, rels] of Object.entries(byPred)) {
+                        lines.push(`\n  [${pred}]`);
+                        for (const r of rels.slice(0, 8)) {
+                            if (r.subject === entityName) {
+                                lines.push(`    → ${r.object}`);
+                            }
+                            else {
+                                lines.push(`    ← ${r.subject}`);
+                            }
                         }
-                        return { text: `❌ ${res.message}` };
+                        if (rels.length > 8)
+                            lines.push(`    ... 还有 ${rels.length - 8} 条`);
                     }
-                    const d = res.data;
-                    const lines = [];
-                    if (d.kb_name)
-                        lines.push(`📚 ${d.kb_name}`);
-                    lines.push(`💡 ${d.answer || "(无答案)"}`);
-                    if (d.faq_data?.question)
-                        lines.push(`📌 匹配: ${d.faq_data.question}`);
-                    if (d.source_nodes?.[0]?.score != null) {
-                        lines.push(`📊 置信度: ${(d.source_nodes[0].score * 100).toFixed(1)}%`);
+                    // Try to find linked FAQs via entity search
+                    try {
+                        const entRes = await client.get(`/knowledge_bases/${kbId}/graph/entities?page=1&size=200`);
+                        if (entRes.success) {
+                            const matchedEnt = (entRes.data?.entities ?? []).find((e) => e.name === entityName || (e.synonyms ?? []).includes(entityName));
+                            if (matchedEnt) {
+                                const faqRes = await client.get(`/knowledge_bases/${kbId}/graph/faq_links/${matchedEnt.id}`);
+                                if (faqRes.success && faqRes.data?.linked_faqs?.length) {
+                                    lines.push(`\n关联FAQ（${faqRes.data.total} 条）:`);
+                                    for (const f of faqRes.data.linked_faqs.slice(0, 5)) {
+                                        lines.push(`  Q: ${f.question.slice(0, 60)} (${f.mention_location})`);
+                                    }
+                                    if (faqRes.data.total > 5)
+                                        lines.push(`  ... 还有 ${faqRes.data.total - 5} 条`);
+                                }
+                            }
+                        }
                     }
+                    catch (_) { }
                     return { text: lines.join("\n") };
                 }
                 catch (e) {
-                    return { text: `❌ 问答失败: ${e.message}` };
+                    return { text: `查询失败: ${e.message}` };
                 }
             },
         });
+        // 8. /linkmind_graph_edit <kb_id> <action> <args> — 编辑知识图谱
         api.registerCommand({
-            name: "linkmind_share",
-            description: "管理知识库权限（仅管理员）: /linkmind_share <KB名称> <用户ID> <角色>",
+            name: "linkmind_graph_edit",
+            description: "编辑图谱: /linkmind_graph_edit <kb_id> <action> <args>",
             acceptsArgs: true,
             handler: async (ctx) => {
-                const authErr = await requireOwner(ctx);
-                if (authErr)
-                    return { text: authErr };
-                const parts = (ctx.args ?? "").trim().split(/\s+/);
-                if (parts.length < 3) {
+                const args = (ctx.args ?? "").trim();
+                if (!args) {
                     return {
                         text: [
-                            "用法: /linkmind_share <KB名称或ID> <目标用户ID> <角色>",
+                            "知识图谱编辑命令:",
+                            "",
+                            "添加实体:",
+                            "  /linkmind_graph_edit <kb_id> add_entity <名称> <类型>",
+                            "  示例: /linkmind_graph_edit kb_xxx add_entity Z7T model",
                             "",
-                            "角色可选:",
-                            "  viewer — 只读（可查询）",
-                            "  editor — 可编辑（可创建/修改 FAQ）",
-                            "  revoke — 撤销权限",
+                            "添加同义词:",
+                            "  /linkmind_graph_edit <kb_id> add_synonym <实体名> <同义词>",
+                            "  示例: /linkmind_graph_edit kb_xxx add_synonym 隔烟屏 挡烟板",
                             "",
-                            "示例:",
-                            "  /linkmind_share 客服知识库 123456789 viewer",
-                            "  /linkmind_share 客服知识库 123456789 revoke",
+                            "添加关系:",
+                            "  /linkmind_graph_edit <kb_id> add_relation <主体> <关系> <客体>",
+                            "  示例: /linkmind_graph_edit kb_xxx add_relation Z7T has_part 止回阀",
+                            "",
+                            "删除实体:",
+                            "  /linkmind_graph_edit <kb_id> del_entity <实体ID>",
+                            "",
+                            "删除关系:",
+                            "  /linkmind_graph_edit <kb_id> del_relation <关系ID>",
+                            "",
+                            "重建映射:",
+                            "  /linkmind_graph_edit <kb_id> rebuild",
+                            "",
+                            "查看/修改Schema:",
+                            "  /linkmind_graph_edit <kb_id> schema",
                         ].join("\n"),
                     };
                 }
-                const [kbNameOrId, targetUserId, action] = parts;
+                const parts = args.split(/\s+/);
+                if (parts.length < 2) {
+                    return { text: "参数不足。用法: /linkmind_graph_edit <kb_id> <action> [args...]" };
+                }
+                const kbId = parts[0];
+                const action = parts[1].toLowerCase();
                 try {
-                    let kbId = kbNameOrId;
-                    try {
-                        const listRes = await client.get(`/knowledge_bases?keyword=${encodeURIComponent(kbNameOrId)}&page_size=0`);
-                        const items = listRes.items ?? listRes.data?.items ?? [];
-                        const exact = items.find((kb) => kb.name === kbNameOrId);
-                        if (exact)
-                            kbId = exact.id;
-                        else if (items.length === 1)
-                            kbId = items[0].id;
+                    switch (action) {
+                        case "add_entity": {
+                            if (parts.length < 4)
+                                return { text: "用法: /linkmind_graph_edit <kb_id> add_entity <名称> <类型>" };
+                            const name = parts[2];
+                            const entityType = parts[3];
+                            const res = await client.post(`/knowledge_bases/${kbId}/graph/entities`, {
+                                name,
+                                entity_type: entityType,
+                                synonyms: parts.length > 4 ? parts.slice(4) : [],
+                            });
+                            if (res.success) {
+                                return { text: `✅ 实体已创建: ${name} (${entityType}) ID=${res.data?.id}\n级联更新已触发。` };
+                            }
+                            return { text: `❌ 创建失败: ${res.detail || res.message}` };
+                        }
+                        case "add_synonym": {
+                            if (parts.length < 4)
+                                return { text: "用法: /linkmind_graph_edit <kb_id> add_synonym <实体名> <同义词>" };
+                            const entityName = parts[2];
+                            const synonym = parts.slice(3).join(" ");
+                            // Find entity by name
+                            const searchRes = await client.get(`/knowledge_bases/${kbId}/graph/entities?search=${encodeURIComponent(entityName)}&size=50`);
+                            if (!searchRes.success || !(searchRes.data?.entities?.length)) {
+                                return { text: `未找到实体 "${entityName}"` };
+                            }
+                            const ent = searchRes.data.entities.find((e) => e.name === entityName);
+                            if (!ent) {
+                                return { text: `未找到精确匹配的实体 "${entityName}"，已有: ${searchRes.data.entities.map((e) => e.name).join(", ")}` };
+                            }
+                            // Update synonyms
+                            const existingSynonyms = ent.synonyms ?? [];
+                            if (existingSynonyms.includes(synonym)) {
+                                return { text: `"${synonym}" 已经是 "${entityName}" 的同义词` };
+                            }
+                            existingSynonyms.push(synonym);
+                            const updateRes = await client.put(`/knowledge_bases/${kbId}/graph/entities/${ent.id}`, {
+                                synonyms: existingSynonyms,
+                            });
+                            if (updateRes.success) {
+                                return { text: `✅ 同义词已添加: "${entityName}" 的同义词现在包括 [${existingSynonyms.join(", ")}]\n级联更新已触发。` };
+                            }
+                            return { text: `❌ 更新失败: ${updateRes.detail || updateRes.message}` };
+                        }
+                        case "add_relation": {
+                            if (parts.length < 5)
+                                return { text: "用法: /linkmind_graph_edit <kb_id> add_relation <主体> <关系> <客体>" };
+                            const subject = parts[2];
+                            const predicate = parts[3];
+                            const object = parts.slice(4).join(" ");
+                            const res = await client.post(`/knowledge_bases/${kbId}/graph/relations`, {
+                                subject,
+                                predicate,
+                                object,
+                            });
+                            if (res.success) {
+                                return { text: `✅ 关系已创建: ${subject} --[${predicate}]--> ${object}  ID=${res.data?.id}\n级联更新已触发。` };
+                            }
+                            return { text: `❌ 创建失败: ${res.detail || res.message}` };
+                        }
+                        case "del_entity": {
+                            if (parts.length < 3)
+                                return { text: "用法: /linkmind_graph_edit <kb_id> del_entity <实体ID>" };
+                            const entityId = parts[2];
+                            const res = await client.del(`/knowledge_bases/${kbId}/graph/entities/${entityId}`);
+                            if (res.success) {
+                                return { text: `✅ 实体 ${entityId} 已删除（关联关系和映射也已清理）` };
+                            }
+                            return { text: `❌ 删除失败: ${res.detail || res.message}` };
+                        }
+                        case "del_relation": {
+                            if (parts.length < 3)
+                                return { text: "用法: /linkmind_graph_edit <kb_id> del_relation <关系ID>" };
+                            const relId = parts[2];
+                            const res = await client.del(`/knowledge_bases/${kbId}/graph/relations/${relId}`);
+                            if (res.success) {
+                                return { text: `✅ 关系 ${relId} 已删除` };
+                            }
+                            return { text: `❌ 删除失败: ${res.detail || res.message}` };
+                        }
+                        case "rebuild": {
+                            const res = await client.post(`/knowledge_bases/${kbId}/graph/rebuild_links`);
+                            if (res.success) {
+                                const d = res.data ?? {};
+                                return { text: `✅ FAQ-实体映射已重建\n  映射总数: ${d.total_mappings ?? "?"}\n  涉及FAQ: ${d.mapped_faqs ?? "?"}\n  涉及实体: ${d.mapped_entities ?? "?"}` };
+                            }
+                            return { text: `❌ 重建失败: ${res.detail || res.message}` };
+                        }
+                        case "schema": {
+                            const res = await client.get(`/knowledge_bases/${kbId}/graph/schema`);
+                            if (!res.success)
+                                return { text: `查询失败: ${res.message}` };
+                            const s = res.data;
+                            if (!s)
+                                return { text: "该知识库尚未配置图谱Schema（使用默认家电模板）" };
+                            const lines = [`图谱Schema (${s.template_name ?? "custom"}):`];
+                            lines.push(`\n实体类型:`);
+                            for (const et of (s.entity_types ?? [])) {
+                                const ex = et.examples?.length ? ` (例: ${et.examples.join(", ")})` : "";
+                                lines.push(`  - ${et.type}: ${et.description}${ex}`);
+                            }
+                            lines.push(`\n关系类型:`);
+                            for (const rt of (s.relation_types ?? [])) {
+                                lines.push(`  - ${rt.predicate}: ${rt.description}`);
+                            }
+                            if (s.model_pattern_regex) {
+                                lines.push(`\n型号正则: ${s.model_pattern_regex}`);
+                            }
+                            return { text: lines.join("\n") };
+                        }
+                        default:
+                            return { text: `未知操作: ${action}\n支持的操作: add_entity, add_synonym, add_relation, del_entity, del_relation, rebuild, schema` };
+                    }
+                }
+                catch (e) {
+                    return { text: `操作失败: ${e.message}` };
+                }
+            },
+        });
+        // 9. /linkmind_term <kb_id> [action] [args] — 术语词典管理(可编辑)
+        api.registerCommand({
+            name: "linkmind_term",
+            description: "术语词典管理: /linkmind_term <kb_id> [action]",
+            acceptsArgs: true,
+            handler: async (ctx) => {
+                const args = (ctx.args ?? "").trim();
+                if (!args) {
+                    return {
+                        text: [
+                            "术语词典管理:",
+                            "",
+                            "查看词典:",
+                            "  /linkmind_term <kb_id>",
+                            "",
+                            "添加单条:",
+                            "  /linkmind_term <kb_id> add <口语> <术语>",
+                            "  示例: /linkmind_term kb_xxx add 板子 导烟板",
+                            "",
+                            "批量添加 (空格分隔, =连接):",
+                            "  /linkmind_term <kb_id> add_batch 板子=导烟板 盖子=油杯盖",
+                            "",
+                            "搜索:",
+                            "  /linkmind_term <kb_id> search <关键词>",
+                            "",
+                            "删除:",
+                            "  /linkmind_term <kb_id> del <口语>",
+                            "",
+                            "导出:",
+                            "  /linkmind_term <kb_id> export",
+                        ].join("\n"),
+                    };
+                }
+                const parts = args.split(/\s+/);
+                const kbId = parts[0];
+                const action = (parts[1] || "").toLowerCase();
+                try {
+                    if (!action || action === "list") {
+                        const res = await client.get(`/knowledge_bases/${kbId}/terminology/export?format=json`);
+                        if (!res.success)
+                            return { text: `查询失败: ${res.message}` };
+                        const items = res.data?.items ?? [];
+                        if (items.length === 0)
+                            return { text: `知识库 ${kbId} 暂无术语词典` };
+                        const lines = [`术语词典 (共 ${items.length} 条):`];
+                        for (const item of items.slice(0, 15)) {
+                            lines.push(`  ${item.pattern} → ${item.replacement}`);
+                        }
+                        if (items.length > 15)
+                            lines.push(`  ... 还有 ${items.length - 15} 条`);
+                        return { text: lines.join("\n") };
                     }
-                    catch { /* use as-is */ }
-                    if (action === "revoke") {
-                        const res = await client.del(`/knowledge_bases/${kbId}/share/${targetUserId}`);
-                        return { text: `✅ ${res.message || "已撤销权限"}` };
+                    if (action === "add") {
+                        if (parts.length < 4)
+                            return { text: "用法: /linkmind_term <kb_id> add <口语> <术语>" };
+                        const pattern = parts[2];
+                        const replacement = parts.slice(3).join(" ");
+                        const res = await client.post(`/knowledge_bases/${kbId}/terminology/batch`, {
+                            items: [{ pattern, replacement }],
+                        });
+                        if (res.success) {
+                            return { text: `✅ 已添加: ${pattern} → ${replacement}` };
+                        }
+                        return { text: `❌ 添加失败: ${res.detail || res.message}` };
                     }
-                    const res = await client.post(`/knowledge_bases/${kbId}/share`, {
-                        target_channel_user_id: targetUserId,
-                        target_channel_type: ctx.channel || "telegram",
-                        channel_bot_id: "default",
-                        role: action,
-                    });
-                    return { text: `✅ ${res.message || `已将 ${targetUserId} 设为 ${action}`}` };
+                    if (action === "add_batch") {
+                        const batchStr = parts.slice(2).join(" ");
+                        const pairs = batchStr.split(/\s+/);
+                        const items = [];
+                        for (const pair of pairs) {
+                            const eqIdx = pair.indexOf("=");
+                            if (eqIdx > 0) {
+                                const p = pair.slice(0, eqIdx).trim();
+                                const r = pair.slice(eqIdx + 1).trim();
+                                if (p && r)
+                                    items.push({ pattern: p, replacement: r });
+                            }
+                        }
+                        if (items.length === 0)
+                            return { text: "格式: /linkmind_term <kb_id> add_batch 口语1=术语1 口语2=术语2" };
+                        const res = await client.post(`/knowledge_bases/${kbId}/terminology/batch`, { items });
+                        if (res.success) {
+                            const d = res.data ?? {};
+                            return { text: `✅ 批量导入: 新增 ${d.imported ?? 0}, 更新 ${d.updated ?? 0}` };
+                        }
+                        return { text: `❌ 导入失败: ${res.detail || res.message}` };
+                    }
+                    if (action === "search") {
+                        if (parts.length < 3)
+                            return { text: "用法: /linkmind_term <kb_id> search <关键词>" };
+                        const keyword = parts.slice(2).join(" ");
+                        const res = await client.get(`/knowledge_bases/${kbId}/terminology/export?format=json`);
+                        if (!res.success)
+                            return { text: `查询失败: ${res.message}` };
+                        const items = (res.data?.items ?? []).filter((i) => i.pattern.includes(keyword) || i.replacement.includes(keyword));
+                        if (items.length === 0)
+                            return { text: `未找到包含 "${keyword}" 的术语` };
+                        const lines = [`搜索结果 (${items.length} 条):`];
+                        for (const item of items.slice(0, 20)) {
+                            lines.push(`  ${item.pattern} → ${item.replacement}`);
+                        }
+                        return { text: lines.join("\n") };
+                    }
+                    if (action === "del") {
+                        if (parts.length < 3)
+                            return { text: "用法: /linkmind_term <kb_id> del <口语>" };
+                        const pattern = parts.slice(2).join(" ");
+                        const res = await client.del(`/knowledge_bases/${kbId}/terminology/batch`, {
+                            patterns: [pattern],
+                        });
+                        if (res.success) {
+                            return { text: `✅ 已删除: ${pattern} (${res.data?.deleted ?? 0} 条)` };
+                        }
+                        return { text: `❌ 删除失败: ${res.detail || res.message}` };
+                    }
+                    if (action === "export") {
+                        const res = await client.get(`/knowledge_bases/${kbId}/terminology/export?format=csv`);
+                        if (!res.success)
+                            return { text: `导出失败: ${res.message}` };
+                        const csv = res.data?.csv ?? "";
+                        const truncated = csv.length > 3000 ? csv.slice(0, 3000) + "\n... (truncated)" : csv;
+                        return { text: `术语词典CSV (${res.data?.total ?? 0} 条):\n${truncated}` };
+                    }
+                    return { text: `未知操作: ${action}\n支持: list, add, add_batch, search, del, export` };
                 }
                 catch (e) {
-                    return { text: `❌ 操作失败: ${e.message}` };
+                    return { text: `操作失败: ${e.message}` };
                 }
             },
         });
+        // 10. /linkmind_graph_view <kb_id> <overview|unmapped|around>
         api.registerCommand({
-            name: "linkmind_list",
-            description: "列出我可访问的知识库",
+            name: "linkmind_graph_view",
+            description: "图谱浏览: /linkmind_graph_view <kb_id> <overview|unmapped|around>",
+            acceptsArgs: true,
             handler: async (ctx) => {
-                const authErr = await ensureAuth(ctx);
-                if (authErr)
-                    return { text: authErr };
+                const args = (ctx.args ?? "").trim();
+                if (!args) {
+                    return {
+                        text: [
+                            "图谱浏览:",
+                            "  /linkmind_graph_view <kb_id> overview  — 全景摘要+Top实体",
+                            "  /linkmind_graph_view <kb_id> unmapped   — 未映射FAQ列表",
+                            "  /linkmind_graph_view <kb_id> around <实体名> — 一跳邻居",
+                        ].join("\n"),
+                    };
+                }
+                const parts = args.split(/\s+/);
+                const kbId = parts[0];
+                const action = (parts[1] || "overview").toLowerCase();
                 try {
-                    const res = await client.get("/knowledge_bases?page=1&page_size=0");
-                    const items = res.items ?? res.data?.items ?? [];
-                    const total = res.total ?? items.length;
-                    const lines = [`📚 知识库（共 ${total} 个）:`];
-                    for (const kb of items) {
-                        const st = kb.is_active ? "✅ 就绪" : "⏳ 未训练";
-                        const tag = kb.tag_name ? ` [${kb.tag_name}]` : "";
-                        const role = kb.my_role ? ` (${kb.my_role})` : "";
-                        lines.push(`  • ${kb.name}${tag}${role}  ${st}\n    ID: ${kb.id}`);
+                    if (action === "overview") {
+                        const res = await client.get(`/knowledge_bases/${kbId}/graph/stats`);
+                        if (!res.success)
+                            return { text: `查询失败: ${res.message}` };
+                        const d = res.data ?? {};
+                        const lines = ["图谱全景摘要:"];
+                        lines.push(`  实体: ${d.total_entities ?? 0}  关系: ${d.total_relations ?? 0}`);
+                        lines.push(`  FAQ映射: ${d.faq_entity_mappings ?? 0} (覆盖 ${d.mapped_faqs ?? 0} FAQs, ${d.mapped_entities ?? 0} 实体)`);
+                        lines.push("\n类型分布:");
+                        for (const [t, c] of Object.entries(d.entity_distribution ?? {})) {
+                            lines.push(`  ${t}: ${c}`);
+                        }
+                        try {
+                            const fullRes = await client.get(`/knowledge_bases/${kbId}/graph/full?max_nodes=500`);
+                            if (fullRes.success) {
+                                const sorted = (fullRes.data?.nodes ?? [])
+                                    .sort((a, b) => (b.faq_count ?? 0) - (a.faq_count ?? 0))
+                                    .slice(0, 10);
+                                if (sorted.length) {
+                                    lines.push("\nTop 10 (关联FAQ最多):");
+                                    for (const n of sorted) {
+                                        const syn = n.synonyms?.length ? ` (${n.synonyms.slice(0, 3).join(",")})` : "";
+                                        lines.push(`  ${n.name} [${n.type}] — ${n.faq_count} FAQs${syn}`);
+                                    }
+                                }
+                            }
+                        }
+                        catch (_) { }
+                        return { text: lines.join("\n") };
                     }
-                    if (items.length === 0)
-                        lines.push("  （暂无可访问的知识库）");
-                    lines.push("", "输入 /linkmind_help 查看更多命令");
-                    return { text: lines.join("\n") };
+                    if (action === "unmapped") {
+                        const res = await client.get(`/knowledge_bases/${kbId}/graph/unmapped_faqs?page=1&size=10`);
+                        if (!res.success)
+                            return { text: `查询失败: ${res.message}` };
+                        const d = res.data ?? {};
+                        if (d.total === 0)
+                            return { text: "所有FAQ都已关联到实体" };
+                        const lines = [`未映射FAQ (共 ${d.total} 条):`];
+                        for (const f of (d.unmapped_faqs ?? [])) {
+                            lines.push(`  Q: ${f.question.slice(0, 60)}`);
+                            lines.push(`     ID: ${f.faq_id}`);
+                        }
+                        return { text: lines.join("\n") };
+                    }
+                    if (action === "around") {
+                        if (parts.length < 3)
+                            return { text: "用法: /linkmind_graph_view <kb_id> around <实体名>" };
+                        const entityName = parts.slice(2).join(" ");
+                        const entRes = await client.get(`/knowledge_bases/${kbId}/graph/entities?search=${encodeURIComponent(entityName)}&size=50`);
+                        if (!entRes.success)
+                            return { text: `查询失败` };
+                        const matched = (entRes.data?.entities ?? []).find((e) => e.name === entityName || (e.synonyms ?? []).includes(entityName));
+                        if (!matched)
+                            return { text: `未找到实体: ${entityName}` };
+                        const nbRes = await client.get(`/knowledge_bases/${kbId}/graph/neighborhood/${matched.id}?hops=1`);
+                        if (!nbRes.success)
+                            return { text: `查询失败` };
+                        const nb = nbRes.data ?? {};
+                        const lines = [`"${entityName}" 的邻居 (${nb.nodes?.length ?? 0} 节点, ${nb.edges?.length ?? 0} 边):`];
+                        const byPred = {};
+                        for (const e of (nb.edges ?? [])) {
+                            if (!byPred[e.predicate])
+                                byPred[e.predicate] = [];
+                            byPred[e.predicate].push(e);
+                        }
+                        for (const [pred, rels] of Object.entries(byPred)) {
+                            lines.push(`\n  [${pred}]`);
+                            for (const r of rels.slice(0, 5)) {
+                                if (r.source === entityName)
+                                    lines.push(`    → ${r.target}`);
+                                else
+                                    lines.push(`    ← ${r.source}`);
+                            }
+                            if (rels.length > 5)
+                                lines.push(`    ... +${rels.length - 5}`);
+                        }
+                        if (nb.linked_faqs?.length) {
+                            lines.push(`\n关联FAQ (${nb.linked_faqs.length} 条):`);
+                            for (const f of nb.linked_faqs.slice(0, 5)) {
+                                lines.push(`  Q: ${f.question.slice(0, 50)}`);
+                            }
+                        }
+                        return { text: lines.join("\n") };
+                    }
+                    return { text: `未知: ${action}\n支持: overview, unmapped, around` };
                 }
                 catch (e) {
-                    return { text: `❌ ${e.message}` };
+                    return { text: `失败: ${e.message}` };
                 }
             },
         });