@ppdocs/mcp 3.2.21 → 3.2.23

package/dist/cli.js

@@ -412,30 +412,29 @@ function generateHooksConfig(cwd) {
         }
     };
 }
-/** 生成 MCP 权限配置 (允许全部 ppdocs-kg 方法) */
+/** 生成 MCP 权限配置 (允许全部 ppdocs-kg 工具) */
 function generateMcpPermissions() {
     const mcpMethods = [
-        // 知识图谱操作
-        'kg_create_node',
-        'kg_delete_node',
-        'kg_update_node',
-        'kg_update_root',
-        'kg_get_rules',
-        'kg_save_rules',
-        'kg_lock_node',
-        'kg_search',
-        'kg_find_path',
-        'kg_list_nodes',
-        'kg_get_relations',
-        'kg_read_node',
-        'kg_get_tree',
-        'kg_find_by_file',
-        // 任务管理
-        'task_create',
-        'task_list',
-        'task_get',
-        'task_add_log',
-        'task_complete',
+        // 初始化 + 导航
+        'kg_init',
+        'kg_status',
+        'kg_tree',
+        // 知识管理
+        'kg_doc',
+        'kg_projects',
+        'kg_rules',
+        // 工作流
+        'kg_task',
+        'kg_files',
+        'kg_discuss',
+        // 流程图
+        'kg_flowchart',
+        // 协作
+        'kg_meeting',
+        // 代码分析
+        'code_scan',
+        'code_smart_context',
+        'code_full_path',
     ];
     return mcpMethods.map(m => `mcp__ppdocs-kg__${m}`);
 }

package/dist/storage/httpClient.d.ts

@@ -34,14 +34,25 @@ export declare class PpdocsApiClient {
     getGlobalRulesMeta(): Promise<Record<string, RuleMeta>>;
     saveGlobalRulesMeta(meta: Record<string, RuleMeta>): Promise<boolean>;
     listTasks(status?: 'active' | 'archived'): Promise<TaskSummary[]>;
-    getTask(taskId: string): Promise<Task | null>;
+    getTask(taskId: string, mode?: 'smart' | 'full'): Promise<Task | null>;
     createTask(task: {
         title: string;
         description: string;
         goals: string[];
     }, creator: string): Promise<Task>;
-    addTaskLog(taskId: string, logType: TaskLogType, content: string): Promise<Task | null>;
+    addTaskLog(taskId: string, content: string, logType?: TaskLogType): Promise<Task | null>;
     completeTask(taskId: string, experience: TaskExperience): Promise<Task | null>;
+    deleteTask(taskId: string): Promise<boolean>;
+    listFlowcharts(): Promise<unknown[]>;
+    getFlowchart(chartId: string): Promise<unknown>;
+    batchAddToFlowchart(chartId: string, nodes: unknown[], edges: unknown[]): Promise<unknown>;
+    saveFlowchart(chartId: string, data: unknown): Promise<unknown>;
+    /** 原子更新单个节点 (后端自动处理并发) */
+    updateFlowchartNode(chartId: string, nodeId: string, node: unknown, changeDesc?: string): Promise<unknown>;
+    /** 原子删除单个节点 (后端自动清理关联边) */
+    deleteFlowchartNode(chartId: string, nodeId: string): Promise<unknown>;
+    getFlowchartOrphans(): Promise<unknown[]>;
+    getFlowchartHealth(): Promise<unknown[]>;
     /** 列出所有可访问的项目 */
     crossListProjects(): Promise<{
         id: string;
@@ -87,12 +98,6 @@ export declare class PpdocsApiClient {
     }>;
     /** 扫描项目代码, 构建/更新索引 */
     analyzerScan(projectPath: string, force?: boolean): Promise<unknown>;
-    /** 查询代码符号 (模糊匹配) */
-    analyzerQuery(projectPath: string, query: string): Promise<unknown>;
-    /** 分层影响分析 (BFS 递归, 可指定深度) */
-    analyzerImpactTree(projectPath: string, symbolName: string, depth?: number): Promise<unknown>;
-    /** 获取文件 360° 上下文 */
-    analyzerContext(projectPath: string, filePath: string): Promise<unknown>;
     /** 智能上下文: 代码+文档+规则+任务全关联 */
     analyzerSmartContext(projectPath: string, symbolName: string): Promise<unknown>;
     /** 全关联路径: 两个符号之间的代码+文档路径 */
@@ -114,10 +119,6 @@ export declare class PpdocsApiClient {
     discussionComplete(id: string): Promise<boolean>;
     /** 删除讨论 (公开路由) */
     discussionDelete(id: string): Promise<boolean>;
-    /** 结案归档讨论 (认证路由) */
-    discussionClose(id: string, conclusion: string): Promise<{
-        archived_path: string;
-    }>;
     /** 列出公共文件 */
     publicFilesList(dir?: string): Promise<FileInfo[]>;
     /** 读取公共文件 (文本) */

package/dist/storage/httpClient.js

@@ -277,9 +277,10 @@ export class PpdocsApiClient {
         const query = status ? `?status=${status}` : '';
         return this.request(`/tasks${query}`);
     }
-    async getTask(taskId) {
+    async getTask(taskId, mode) {
         try {
-            return await this.request(`/tasks/${taskId}`);
+            const query = mode ? `?mode=${mode}` : '';
+            return await this.request(`/tasks/${taskId}${query}`);
         }
         catch {
             return null;
@@ -300,11 +301,14 @@ export class PpdocsApiClient {
             body: JSON.stringify(payload)
         });
     }
-    async addTaskLog(taskId, logType, content) {
+    async addTaskLog(taskId, content, logType) {
         try {
+            const body = { content };
+            if (logType)
+                body.log_type = logType;
             return await this.request(`/tasks/${taskId}/logs`, {
                 method: 'POST',
-                body: JSON.stringify({ log_type: logType, content })
+                body: JSON.stringify(body)
             });
         }
         catch {
@@ -322,6 +326,58 @@ export class PpdocsApiClient {
             return null;
         }
     }
+    async deleteTask(taskId) {
+        try {
+            await this.request(`/tasks/${taskId}`, { method: 'DELETE' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ============ 流程图管理 ============
+    async listFlowcharts() {
+        return this.request('/flowcharts');
+    }
+    async getFlowchart(chartId) {
+        try {
+            return await this.request(`/flowcharts/${chartId}`);
+        }
+        catch {
+            return null;
+        }
+    }
+    async batchAddToFlowchart(chartId, nodes, edges) {
+        return this.request(`/flowcharts/${chartId}/batch`, {
+            method: 'POST',
+            body: JSON.stringify({ nodes, edges })
+        });
+    }
+    async saveFlowchart(chartId, data) {
+        return this.request(`/flowcharts/${chartId}`, {
+            method: 'PUT',
+            body: JSON.stringify(data)
+        });
+    }
+    /** 原子更新单个节点 (后端自动处理并发) */
+    async updateFlowchartNode(chartId, nodeId, node, changeDesc) {
+        return this.request(`/flowcharts/${chartId}/nodes/${nodeId}`, {
+            method: 'PUT',
+            body: JSON.stringify({ node, change_desc: changeDesc || 'MCP update' })
+        });
+    }
+    /** 原子删除单个节点 (后端自动清理关联边) */
+    async deleteFlowchartNode(chartId, nodeId) {
+        return this.request(`/flowcharts/${chartId}/nodes/${nodeId}`, {
+            method: 'DELETE'
+        });
+    }
+    async getFlowchartOrphans() {
+        return this.request('/flowcharts/orphans');
+    }
+    async getFlowchartHealth() {
+        return this.request('/flowcharts/health');
+    }
     // ============ 跨项目只读访问 ============
     /** 列出所有可访问的项目 */
     async crossListProjects() {
@@ -465,27 +521,6 @@ export class PpdocsApiClient {
             body: JSON.stringify({ project_path: projectPath, force }),
         });
     }
-    /** 查询代码符号 (模糊匹配) */
-    async analyzerQuery(projectPath, query) {
-        return this.request('/analyzer/query', {
-            method: 'POST',
-            body: JSON.stringify({ project_path: projectPath, query }),
-        });
-    }
-    /** 分层影响分析 (BFS 递归, 可指定深度) */
-    async analyzerImpactTree(projectPath, symbolName, depth = 2) {
-        return this.request('/analyzer/impact-tree', {
-            method: 'POST',
-            body: JSON.stringify({ project_path: projectPath, symbol_name: symbolName, depth }),
-        });
-    }
-    /** 获取文件 360° 上下文 */
-    async analyzerContext(projectPath, filePath) {
-        return this.request('/analyzer/context', {
-            method: 'POST',
-            body: JSON.stringify({ project_path: projectPath, file_path: filePath }),
-        });
-    }
     /** 智能上下文: 代码+文档+规则+任务全关联 */
     async analyzerSmartContext(projectPath, symbolName) {
         return this.request('/analyzer/smart-context', {
@@ -560,13 +595,6 @@ export class PpdocsApiClient {
             method: 'DELETE',
         });
     }
-    /** 结案归档讨论 (认证路由) */
-    async discussionClose(id, conclusion) {
-        return this.request(`/discussions/${encodeURIComponent(id)}/close`, {
-            method: 'POST',
-            body: JSON.stringify({ conclusion }),
-        });
-    }
     // ============ 公共文件池 ============
     /** 列出公共文件 */
     async publicFilesList(dir) {

package/dist/tools/analyzer.d.ts

@@ -1,8 +1,9 @@
 /**
- * 代码分析引擎工具 (4个)
- * code_scan, code_query, code_impact, code_context
+ * 代码分析引擎工具 (3个)
+ * code_scan, code_smart_context, code_full_path
  *
- * 让 AI Agent 通过 MCP 工具直接查询代码结构、依赖关系和影响范围
+ * code_smart_context: 代码+KG文档全关联 (含影响范围)
+ * code_full_path: 两点间代码链路+共享KG文档
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type McpContext } from './shared.js';

package/dist/tools/analyzer.js

@@ -1,8 +1,9 @@
 /**
- * 代码分析引擎工具 (4个)
- * code_scan, code_query, code_impact, code_context
+ * 代码分析引擎工具 (3个)
+ * code_scan, code_smart_context, code_full_path
  *
- * 让 AI Agent 通过 MCP 工具直接查询代码结构、依赖关系和影响范围
+ * code_smart_context: 代码+KG文档全关联 (含影响范围)
+ * code_full_path: 两点间代码链路+共享KG文档
  */
 import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
@@ -13,13 +14,10 @@ const SYMBOL_ICONS = {
     type_alias: '𝐓', enum: '𝐄', struct: '𝐒', trait: '⚡',
     constant: '𝐊', variable: '𝑣',
 };
-const SEVERITY_ICONS = {
-    critical: '🔴', warning: '🟡', info: '🟢',
-};
 export function registerAnalyzerTools(server, ctx) {
     const client = () => getClient();
     // ===== code_scan: 扫描项目代码 =====
-    server.tool('code_scan', '📡 扫描项目代码, 构建索引。返回文件数、符号数、语言统计。★首次使用 code_query/code_impact/code_context 前必须先执行★', {
+    server.tool('code_scan', '📡 扫描项目代码, 构建索引。返回文件数、符号数、语言统计。★首次使用 code_smart_context/code_full_path 前必须先执行★', {
         projectPath: z.string().optional().describe('项目源码的绝对路径(如"D:/projects/myapp")。不传则自动从Beacon同步目录或项目配置解析'),
         force: z.boolean().optional().describe('是否强制全量重建(默认false, 增量更新)'),
     }, async (args) => safeTool(async () => {
@@ -34,235 +32,8 @@ export function registerAnalyzerTools(server, ctx) {
             `- 索引时间: ${result.indexedAt}`,
         ].join('\n'));
     }));
-    // ===== code_query: 搜索代码符号 =====
-    server.tool('code_query', '🔤 搜索代码符号(函数/类/方法/接口/类型)。返回匹配列表+文件路径+行号。定位代码位置的最快方式。需先运行 code_scan', {
-        projectPath: z.string().optional().describe('项目源码的绝对路径(不传则自动解析)'),
-        query: z.string().describe('搜索关键词(函数名/类名/方法名等)'),
-    }, async (args) => safeTool(async () => {
-        const results = await client().analyzerQuery(args.projectPath || '', args.query);
-        if (!results || results.length === 0) {
-            return wrap(`未找到匹配 "${args.query}" 的符号。请确认已运行 code_scan`);
-        }
-        const lines = results.map(r => {
-            const icon = SYMBOL_ICONS[r.symbol.kind] || '?';
-            const exp = r.symbol.exported ? ' [export]' : '';
-            const parent = r.symbol.parent ? ` ◀ ${r.symbol.parent}` : '';
-            return `  ${icon} ${r.symbol.name}${parent}${exp}  →  ${r.filePath}:${r.symbol.lineStart}`;
-        });
-        return wrap([
-            `🔤 找到 ${results.length} 个匹配符号:`,
-            ``,
-            ...lines,
-        ].join('\n'));
-    }));
-    // ===== code_impact: 分层影响分析 =====
-    server.tool('code_impact', '💥 爆炸半径分析 ★修改代码前必查★ 分析修改一个函数/类/类型会影响多少文件。BFS分层输出: L1🔴直接引用=必须检查, L2🟡间接引用=建议检查, L3🟢传递引用=注意。修改任何公共接口、函数签名、类型定义前务必先运行!', {
-        projectPath: z.string().optional().describe('项目源码的绝对路径(不传则自动解析)'),
-        symbolName: z.string().describe('要分析的符号名称(如"AuthService", "handleLogin")'),
-        depth: z.number().optional().describe('分析深度层级(1-5, 默认2)。1=仅直接引用, 3=深度追踪'),
-    }, async (args) => safeTool(async () => {
-        const result = await client().analyzerImpactTree(args.projectPath || '', args.symbolName, args.depth ?? 2);
-        if (!result) {
-            return wrap(`未找到符号 "${args.symbolName}"。请确认名称正确且已运行 code_scan`);
-        }
-        if (result.levels.length === 0) {
-            return wrap(`✅ "${args.symbolName}" 没有被其他文件引用, 修改安全`);
-        }
-        // 生成分层树形输出
-        const lines = [
-            `🎯 ${result.symbolName} (${result.symbolKind})`,
-            `📍 定义: ${result.definedIn}:${result.lineStart}`,
-            ``,
-            `📊 ${result.summary}`,
-            ``,
-        ];
-        for (const level of result.levels) {
-            const icon = SEVERITY_ICONS[level.severity] || '⚪';
-            const label = level.depth === 1 ? '直接引用 (必须检查)' :
-                level.depth === 2 ? '间接引用 (建议检查)' :
-                    '传递引用 (注意)';
-            lines.push(`### ${icon} L${level.depth} ${label} (${level.count}个)`);
-            for (const entry of level.entries) {
-                lines.push(`  ${entry.filePath}:${entry.line}  [${entry.refKind}]  ${entry.context}`);
-            }
-            lines.push('');
-        }
-        return wrap(lines.join('\n'));
-    }));
-    // ===== code_context: 文件360°上下文 =====
-    server.tool('code_context', '🔍 文件360°上下文 — 定义了什么符号、导入了什么、被谁引用。修改文件前使用, 快速了解所有依赖关系, 避免遗漏', {
-        projectPath: z.string().optional().describe('项目源码的绝对路径(不传则自动解析)'),
-        filePath: z.string().describe('目标文件的相对路径(如"src/services/auth.ts")'),
-    }, async (args) => safeTool(async () => {
-        const fileCtx = await client().analyzerContext(args.projectPath || '', args.filePath);
-        if (!fileCtx) {
-            return wrap(`未找到文件 "${args.filePath}"。请确认路径正确, 路径格式为相对路径(如 src/main.ts)`);
-        }
-        const lines = [
-            `📄 ${fileCtx.filePath}`,
-            `语言: ${fileCtx.language} | ${fileCtx.linesTotal} 行`,
-            ``,
-        ];
-        // 定义的符号
-        if (fileCtx.symbolsDefined.length > 0) {
-            lines.push(`### 🔤 定义的符号 (${fileCtx.symbolsDefined.length})`);
-            for (const sym of fileCtx.symbolsDefined) {
-                const icon = SYMBOL_ICONS[sym.kind] || '?';
-                const exp = sym.exported ? ' [export]' : '';
-                lines.push(`  ${icon} ${sym.name}${exp}  L${sym.lineStart}-L${sym.lineEnd}`);
-            }
-            lines.push('');
-        }
-        // 导入
-        if (fileCtx.imports.length > 0) {
-            lines.push(`### 📥 导入 (${fileCtx.imports.length})`);
-            for (const imp of fileCtx.imports) {
-                const specs = imp.specifiers.length > 0 ? `{ ${imp.specifiers.join(', ')} }` : '*';
-                lines.push(`  → ${imp.source}  ${specs}  L${imp.line}`);
-            }
-            lines.push('');
-        }
-        // 被谁引用
-        if (fileCtx.importedBy.length > 0) {
-            lines.push(`### 📤 被引用 (${fileCtx.importedBy.length})`);
-            for (const by of fileCtx.importedBy) {
-                const specs = by.specifiers.length > 0 ? `{ ${by.specifiers.join(', ')} }` : '';
-                lines.push(`  ← ${by.filePath}  ${specs}`);
-            }
-            lines.push('');
-        }
-        return wrap(lines.join('\n'));
-    }));
-    // ===== code_path: 两点间链路追踪 =====
-    server.tool('code_path', '🔗 两点链路追踪 — 给定两个符号(如 fileA.funcA 和 fileB.funcB)，自动搜索中间的引用链路，返回完整路径 + 绑定的知识图谱文档', {
-        projectPath: z.string().optional().describe('项目源码的绝对路径(不传则自动解析)'),
-        symbolA: z.string().describe('起点符号名(如 "handleLogin")'),
-        symbolB: z.string().describe('终点符号名(如 "AuthService")'),
-        maxDepth: z.number().optional().describe('最大搜索深度(1-5, 默认3)'),
-    }, async (args) => safeTool(async () => {
-        const depth = Math.min(5, Math.max(1, args.maxDepth ?? 3));
-        const pp = args.projectPath || '';
-        // 1. 获取两个符号的影响树
-        const [treeA, treeB] = await Promise.all([
-            client().analyzerImpactTree(pp, args.symbolA, depth),
-            client().analyzerImpactTree(pp, args.symbolB, depth),
-        ]);
-        if (!treeA)
-            return wrap(`❌ 未找到起点符号 "${args.symbolA}"。请确认名称正确且已运行 code_scan`);
-        if (!treeB)
-            return wrap(`❌ 未找到终点符号 "${args.symbolB}"。请确认名称正确且已运行 code_scan`);
-        const graphA = new Map(); // 从 A 出发可达的文件
-        const graphB = new Map(); // 从 B 出发可达的文件
-        const buildGraph = (tree, graph) => {
-            graph.set(tree.definedIn, []);
-            for (const level of tree.levels) {
-                for (const entry of level.entries) {
-                    if (!graph.has(entry.filePath))
-                        graph.set(entry.filePath, []);
-                    graph.get(entry.filePath).push({
-                        file: entry.filePath,
-                        line: entry.line,
-                        depth: level.depth,
-                        from: tree.symbolName,
-                    });
-                }
-            }
-        };
-        buildGraph(treeA, graphA);
-        buildGraph(treeB, graphB);
-        // 3. 查找交集: A 和 B 都能到达的文件
-        const intersection = [];
-        for (const [fileA] of graphA) {
-            if (graphB.has(fileA)) {
-                const refsA = graphA.get(fileA);
-                const refsB = graphB.get(fileA);
-                const minDepthA = refsA.length > 0 ? Math.min(...refsA.map(r => r.depth)) : 0;
-                const minDepthB = refsB.length > 0 ? Math.min(...refsB.map(r => r.depth)) : 0;
-                intersection.push({ file: fileA, depthFromA: minDepthA, depthFromB: minDepthB });
-            }
-        }
-        // 4. 尝试获取 KG 文档绑定
-        let docBindings = {};
-        try {
-            const docClient = client();
-            const allDocs = await docClient.listDocs();
-            for (const doc of allDocs) {
-                if (!doc.isDir && doc.summary) {
-                    docBindings[doc.name] = doc.summary;
-                }
-            }
-        }
-        catch { /* KG 不可用时忽略 */ }
-        // 5. 格式化输出
-        const lines = [
-            `🔗 两点链路追踪`,
-            ``,
-            `📍 起点: ${treeA.symbolName} (${treeA.symbolKind}) → ${treeA.definedIn}:${treeA.lineStart}`,
-            `📍 终点: ${treeB.symbolName} (${treeB.symbolKind}) → ${treeB.definedIn}:${treeB.lineStart}`,
-            ``,
-        ];
-        // 直接引用关系
-        if (treeA.definedIn === treeB.definedIn) {
-            lines.push(`✅ 两个符号定义在同一文件中！`);
-            lines.push('');
-        }
-        // 检查 A 的影响树是否直接包含 B 的文件
-        const directAtoB = graphA.has(treeB.definedIn);
-        const directBtoA = graphB.has(treeA.definedIn);
-        if (directAtoB || directBtoA) {
-            lines.push(`### ✅ 发现直接链路`);
-            if (directAtoB) {
-                const refs = graphA.get(treeB.definedIn);
-                lines.push(`  ${treeA.symbolName} → [L${refs[0]?.depth || 1}] → ${treeB.definedIn} (含 ${treeB.symbolName})`);
-            }
-            if (directBtoA) {
-                const refs = graphB.get(treeA.definedIn);
-                lines.push(`  ${treeB.symbolName} → [L${refs[0]?.depth || 1}] → ${treeA.definedIn} (含 ${treeA.symbolName})`);
-            }
-            lines.push('');
-        }
-        if (intersection.length > 0) {
-            // 按总深度排序
-            intersection.sort((a, b) => (a.depthFromA + a.depthFromB) - (b.depthFromA + b.depthFromB));
-            lines.push(`### 🔗 共经文件 (${intersection.length}个)`);
-            lines.push(`| 文件 | 距${treeA.symbolName} | 距${treeB.symbolName} | 📚 绑定文档 |`);
-            lines.push(`|:---|:---:|:---:|:---|`);
-            for (const node of intersection.slice(0, 20)) {
-                const fileName = node.file.split('/').pop() || node.file;
-                const docBind = docBindings[fileName] || '—';
-                lines.push(`| ${node.file} | L${node.depthFromA} | L${node.depthFromB} | ${docBind} |`);
-            }
-            if (intersection.length > 20) {
-                lines.push(`| ... | | | (还有 ${intersection.length - 20} 个) |`);
-            }
-            lines.push('');
-        }
-        else if (!directAtoB && !directBtoA) {
-            lines.push(`⚠️ 在 ${depth} 层深度内未发现 ${treeA.symbolName} 与 ${treeB.symbolName} 的引用链路`);
-            lines.push(`建议: 增加 maxDepth 参数(当前=${depth}, 最大=5) 重试`);
-            lines.push('');
-        }
-        // 附加: 各符号的影响概要
-        lines.push(`### 📊 影响概要`);
-        lines.push(`- ${treeA.symbolName}: ${treeA.summary}`);
-        lines.push(`- ${treeB.symbolName}: ${treeB.summary}`);
-        // 附加: 绑定的 KG 文档
-        const relevantDocs = [];
-        const symbolNames = [treeA.symbolName, treeB.symbolName];
-        for (const [docName, docSummary] of Object.entries(docBindings)) {
-            if (symbolNames.some(s => docName.toLowerCase().includes(s.toLowerCase()) || s.toLowerCase().includes(docName.toLowerCase()))) {
-                relevantDocs.push(`  📚 ${docName}: ${docSummary}`);
-            }
-        }
-        if (relevantDocs.length > 0) {
-            lines.push('');
-            lines.push(`### 📚 相关知识图谱文档`);
-            lines.push(...relevantDocs);
-        }
-        return wrap(lines.join('\n'));
-    }));
     // ===== code_smart_context: 代码+文档全关联上下文 =====
-    server.tool('code_smart_context', '🔍 代码+文档全关联上下文 — 输入一个函数名，一次调用返回：代码依赖、关联文档、匹配规则、活跃任务、影响范围摘要。需先运行 code_scan', {
+    server.tool('code_smart_context', '🔍 代码+文档全关联上下文 — 输入一个函数名,一次调用返回:代码依赖、关联文档、匹配规则、活跃任务、影响范围摘要。需先运行 code_scan', {
         projectPath: z.string().optional().describe('项目源码的绝对路径(不传则自动解析)'),
         symbolName: z.string().describe('要查询的符号名称(如"handleLogin", "AuthService")'),
     }, async (args) => safeTool(async () => {
@@ -322,7 +93,7 @@ export function registerAnalyzerTools(server, ctx) {
         return wrap(lines.join('\n'));
     }));
     // ===== code_full_path: 全关联路径 =====
-    server.tool('code_full_path', '🔗 全关联路径 — 两个符号之间不仅返回代码引用链路，还返回共享的KG文档、共同导入、祖先模块。需先运行 code_scan', {
+    server.tool('code_full_path', '🔗 全关联路径 — 两个符号之间不仅返回代码引用链路,还返回共享的KG文档、共同导入、祖先模块。需先运行 code_scan', {
         projectPath: z.string().optional().describe('项目源码的绝对路径(不传则自动解析)'),
         symbolA: z.string().describe('起点符号名(如 "handleLogin")'),
         symbolB: z.string().describe('终点符号名(如 "AuthService")'),

package/dist/tools/discussion.d.ts

@@ -1,8 +1,14 @@
 /**
- * 💬 kg_discuss (6→1)
- * 合并: list, read, create, reply, close, delete
+ * 💬 kg_discuss (8 actions)
+ * 合并: list, read, create, reply, close, delete, complete, history
  * 统一走 HTTP → Rust 后端 (单一写入者)
  * sender 格式: "projectId:user" (如 "p-ca3sgejg:张三")
+ *
+ * 权限模型:
+ *   list/history  — 任何人可列出(全局可见)
+ *   create        — 任何人可发起(指定参与项目ID)
+ *   read/reply    — 仅讨论组内成员(initiator + participants)
+ *   complete/close/delete — 仅发起人
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type McpContext } from './shared.js';