@ppdocs/mcp 3.2.21 → 3.2.23

package/dist/tools/flowchart.js

@@ -0,0 +1,483 @@
+/**
+ * 🔀 kg_flowchart — 逻辑流程图批量操作
+ * AI 一次提交所有节点+边, 后端原子处理, 返回孤立检测结果
+ */
+import { z } from 'zod';
+import { getClient } from '../storage/httpClient.js';
+import { decodeObjectStrings } from '../utils.js';
+import { wrap, safeTool } from './shared.js';
+const NodeSchema = z.object({
+    id: z.string().describe('节点唯一ID'),
+    label: z.string().describe('节点标签'),
+    description: z.string().optional().describe('节点描述'),
+    nodeType: z.string().optional().describe('节点类型: super|process|data|entry'),
+    domain: z.string().optional().describe('领域: frontend|backend|mcp|system|infra'),
+    input: z.array(z.string()).optional(),
+    output: z.array(z.string()).optional(),
+    affiliation: z.string().optional().describe('父节点ID, 默认root'),
+});
+const EdgeSchema = z.object({
+    from: z.string().describe('起点节点ID'),
+    to: z.string().describe('终点节点ID'),
+    label: z.string().optional().describe('连线标签'),
+    edgeType: z.string().optional().describe('类型: call|event|data|reference'),
+});
+export function registerFlowchartTools(server, ctx) {
+    const client = () => getClient();
+    server.tool('kg_flowchart', '🔀 逻辑流程图(关系型知识锚点) — action: list|get|get_node(★爆炸式上下文)|update_node|delete_node|batch_add|bind|unbind|orphans|health', {
+        action: z.enum(['list', 'get', 'get_node', 'update_node', 'delete_node', 'batch_add', 'bind', 'unbind', 'orphans', 'health'])
+            .describe('操作类型'),
+        chartId: z.string().optional()
+            .describe('流程图ID (默认"main")'),
+        nodeId: z.string().optional()
+            .describe('节点ID (get_node/update_node/delete_node/bind/unbind)'),
+        // get_node 爆炸扩展控制 (全部默认开启, AI可选择性关闭)
+        expand: z.number().optional()
+            .describe('get_node: 连线扩展层数(默认3, 0=不扩展)'),
+        includeDocs: z.boolean().optional()
+            .describe('get_node: 显示绑定的参考文档摘要(默认true)'),
+        includeTasks: z.boolean().optional()
+            .describe('get_node: 显示绑定的任务摘要(默认true)'),
+        includeFiles: z.boolean().optional()
+            .describe('get_node: 显示绑定的代码文件(默认true)'),
+        includeDoc: z.boolean().optional()
+            .describe('get_node: 显示节点技术文档(默认true)'),
+        // update_node 更新字段
+        label: z.string().optional().describe('update_node: 新标签'),
+        description: z.string().optional().describe('update_node: 新描述'),
+        nodeType: z.string().optional().describe('update_node: 新类型'),
+        domain: z.string().optional().describe('update_node: 新领域'),
+        input: z.array(z.string()).optional().describe('update_node: 新输入 / bind的源代码文件'),
+        output: z.array(z.string()).optional().describe('update_node: 新输出'),
+        // bind/unbind
+        files: z.array(z.string()).optional()
+            .describe('源代码文件路径 (bind/unbind)'),
+        dirs: z.array(z.string()).optional()
+            .describe('源代码目录路径 (bind/unbind)'),
+        docs: z.array(z.string()).optional()
+            .describe('知识文档路径 (bind/unbind)'),
+        tasks: z.array(z.string()).optional()
+            .describe('任务ID (bind/unbind)'),
+        // batch_add
+        nodes: z.array(NodeSchema).optional()
+            .describe('批量添加的节点数组 (batch_add)'),
+        edges: z.array(EdgeSchema).optional()
+            .describe('批量添加的边数组 (batch_add)'),
+    }, async (args) => safeTool(async () => {
+        const decoded = decodeObjectStrings(args);
+        switch (decoded.action) {
+            case 'list': {
+                const charts = await client().listFlowcharts();
+                if (!charts || charts.length === 0)
+                    return wrap('📋 暂无流程图');
+                const list = charts
+                    .map(c => `• ${c.title} [${c.id}] — ${c.nodeCount}节点 ${c.edgeCount}连线`)
+                    .join('\n');
+                return wrap(`📋 流程图列表:\n\n${list}`);
+            }
+            case 'get': {
+                const chartId = decoded.chartId || 'main';
+                const chart = await client().getFlowchart(chartId);
+                if (!chart)
+                    return wrap(`❌ 流程图 "${chartId}" 不存在`);
+                const nodes = chart.nodes || [];
+                const edges = chart.edges || [];
+                const lines = [
+                    `📊 ${chart.title || chartId} [${chartId}]`,
+                    chart.parentChart ? `↩ 父图: ${chart.parentChart}` : '',
+                    ``,
+                    `### 节点 (${nodes.length})`,
+                    ...nodes.map((n) => `  • ${n.label} [${n.id}] (${n.nodeType}/${n.domain}) ${n.boundDocs?.length ? `📄${n.boundDocs.length}` : ''} ${n.boundTasks?.length ? `📝${n.boundTasks.length}` : ''} ${n.boundFiles?.length ? `📂${n.boundFiles.length}` : ''}`),
+                    ``,
+                    `### 连线 (${edges.length})`,
+                    ...edges.map((e) => `  ${e.from} →${e.label ? `[${e.label}]` : ''} ${e.to}`),
+                ].filter(Boolean);
+                return wrap(lines.join('\n'));
+            }
+            case 'get_node': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId)
+                    return wrap('❌ get_node 需要 nodeId');
+                const chart = await client().getFlowchart(chartId);
+                if (!chart)
+                    return wrap(`❌ 流程图 "${chartId}" 不存在`);
+                const allNodes = chart.nodes || [];
+                const allEdges = chart.edges || [];
+                const target = allNodes.find((n) => n.id === decoded.nodeId);
+                if (!target)
+                    return wrap(`❌ 节点 "${decoded.nodeId}" 不存在于 "${chartId}"`);
+                // 扩展参数 (全部默认开启)
+                const expandDepth = decoded.expand !== undefined ? Number(decoded.expand) : 3;
+                const showDocs = decoded.includeDocs !== false;
+                const showTasks = decoded.includeTasks !== false;
+                const showFiles = decoded.includeFiles !== false;
+                const showDoc = decoded.includeDoc !== false;
+                const nodeMap = new Map(allNodes.map((n) => [n.id, n]));
+                const lines = [];
+                // ======== 节点基础信息 ========
+                lines.push(`🔍 节点详情: ${target.label} [${target.id}]`);
+                lines.push(`类型: ${target.nodeType || 'process'} | 领域: ${target.domain || 'system'}`);
+                if (target.description)
+                    lines.push(`📝 ${target.description}`);
+                if (target.input?.length)
+                    lines.push(`📥 输入: ${target.input.join(', ')}`);
+                if (target.output?.length)
+                    lines.push(`📤 输出: ${target.output.join(', ')}`);
+                if (target.subFlowchart)
+                    lines.push(`📂 子流程图: ${target.subFlowchart}`);
+                if (target.lastUpdated)
+                    lines.push(`🕐 最后更新: ${target.lastUpdated}`);
+                lines.push('');
+                // ======== 节点技术文档 ========
+                if (showDoc && target.doc) {
+                    lines.push(`### 📖 技术文档`);
+                    lines.push(`版本: ${target.doc.version} | ${target.doc.date}`);
+                    if (target.doc.overview)
+                        lines.push(target.doc.overview);
+                    if (target.doc.details?.length) {
+                        for (const d of target.doc.details) {
+                            lines.push(`  **${d.section}**: ${d.content?.substring(0, 200)}`);
+                        }
+                    }
+                    lines.push('');
+                }
+                // ======== 爆炸扩展: N层关联节点 ========
+                if (expandDepth > 0) {
+                    const visited = new Set([target.id]);
+                    let frontier = [target.id];
+                    const layerResults = [];
+                    for (let depth = 1; depth <= expandDepth; depth++) {
+                        const nextFrontier = [];
+                        const layerLines = [];
+                        for (const currentId of frontier) {
+                            // 出边
+                            for (const e of allEdges) {
+                                if (e.from === currentId && !visited.has(e.to)) {
+                                    visited.add(e.to);
+                                    nextFrontier.push(e.to);
+                                    const neighbor = nodeMap.get(e.to);
+                                    const label = neighbor?.label || e.to;
+                                    layerLines.push(`  → ${label} [${e.to}] ${e.label ? `(${e.label})` : ''} ${e.edgeType ? `[${e.edgeType}]` : ''}`);
+                                }
+                                // 入边
+                                if (e.to === currentId && !visited.has(e.from)) {
+                                    visited.add(e.from);
+                                    nextFrontier.push(e.from);
+                                    const neighbor = nodeMap.get(e.from);
+                                    const label = neighbor?.label || e.from;
+                                    layerLines.push(`  ← ${label} [${e.from}] ${e.label ? `(${e.label})` : ''} ${e.edgeType ? `[${e.edgeType}]` : ''}`);
+                                }
+                            }
+                        }
+                        if (layerLines.length > 0)
+                            layerResults.push(layerLines);
+                        frontier = nextFrontier;
+                        if (frontier.length === 0)
+                            break;
+                    }
+                    if (layerResults.length > 0) {
+                        lines.push(`### 🔗 关联节点 (扩展${layerResults.length}层, 共${visited.size - 1}个)`);
+                        layerResults.forEach((layer, i) => {
+                            lines.push(`**L${i + 1}** (${layer.length}个):`);
+                            lines.push(...layer);
+                        });
+                        lines.push('');
+                    }
+                }
+                // ======== 绑定的参考文档 ========
+                if (showDocs && target.boundDocs?.length) {
+                    lines.push(`### 📄 绑定参考文档 (${target.boundDocs.length})`);
+                    for (const docPath of target.boundDocs) {
+                        try {
+                            const doc = await client().getDoc(docPath);
+                            if (doc) {
+                                lines.push(`  📄 ${docPath} — ${doc.summary || '无摘要'}`);
+                                if (doc.status)
+                                    lines.push(`     状态: ${doc.status}`);
+                            }
+                            else {
+                                lines.push(`  📄 ${docPath} (未找到)`);
+                            }
+                        }
+                        catch {
+                            lines.push(`  📄 ${docPath}`);
+                        }
+                    }
+                    lines.push('');
+                }
+                // ======== 绑定的任务 ========
+                if (showTasks && target.boundTasks?.length) {
+                    lines.push(`### 📝 绑定任务 (${target.boundTasks.length})`);
+                    for (const taskId of target.boundTasks) {
+                        try {
+                            const task = await client().getTask(taskId);
+                            if (task) {
+                                lines.push(`  📝 [${taskId}] ${task.title} — ${task.status}`);
+                            }
+                            else {
+                                lines.push(`  📝 [${taskId}] (未找到)`);
+                            }
+                        }
+                        catch {
+                            lines.push(`  📝 [${taskId}]`);
+                        }
+                    }
+                    lines.push('');
+                }
+                // ======== 绑定的代码文件 ========
+                if (showFiles) {
+                    const files = target.boundFiles || [];
+                    const dirs = target.boundDirs || [];
+                    if (files.length + dirs.length > 0) {
+                        lines.push(`### 📂 绑定代码 (${files.length}文件 ${dirs.length}目录)`);
+                        for (const f of files)
+                            lines.push(`  📄 ${f}`);
+                        for (const d of dirs)
+                            lines.push(`  📁 ${d}`);
+                        lines.push('');
+                    }
+                }
+                // ======== 版本历史 ========
+                if (target.versions?.length) {
+                    lines.push(`### 📋 版本历史 (${target.versions.length})`);
+                    for (const v of target.versions.slice(-5)) {
+                        lines.push(`  v${v.version} (${v.date}): ${v.changes}`);
+                    }
+                }
+                return wrap(lines.join('\n'));
+            }
+            case 'update_node': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId)
+                    return wrap('❌ update_node 需要 nodeId');
+                // 构建待更新的节点字段
+                const updates = { id: decoded.nodeId };
+                const changes = [];
+                if (decoded.label !== undefined) {
+                    updates.label = decoded.label;
+                    changes.push('label');
+                }
+                if (decoded.description !== undefined) {
+                    updates.description = decoded.description;
+                    changes.push('description');
+                }
+                if (decoded.nodeType !== undefined) {
+                    updates.nodeType = decoded.nodeType;
+                    changes.push('nodeType');
+                }
+                if (decoded.domain !== undefined) {
+                    updates.domain = decoded.domain;
+                    changes.push('domain');
+                }
+                if (decoded.input !== undefined) {
+                    updates.input = decoded.input;
+                    changes.push('input');
+                }
+                if (decoded.output !== undefined) {
+                    updates.output = decoded.output;
+                    changes.push('output');
+                }
+                if (changes.length === 0)
+                    return wrap('ℹ️ 无变更 — 请提供要更新的字段');
+                updates.lastUpdated = new Date().toISOString();
+                // 原子调用: PUT /flowcharts/:chartId/nodes/:nodeId
+                await client().updateFlowchartNode(chartId, decoded.nodeId, updates, `MCP更新: ${changes.join(', ')}`);
+                return wrap(`✅ 节点已更新: ${decoded.label || decoded.nodeId} [${chartId}/${decoded.nodeId}]\n更新字段: ${changes.join(', ')}`);
+            }
+            case 'delete_node': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId)
+                    return wrap('❌ delete_node 需要 nodeId');
+                // 原子调用: DELETE /flowcharts/:chartId/nodes/:nodeId (后端自动清理关联边)
+                await client().deleteFlowchartNode(chartId, decoded.nodeId);
+                return wrap(`✅ 节点已删除 [${chartId}/${decoded.nodeId}]`);
+            }
+            case 'batch_add': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodes || decoded.nodes.length === 0) {
+                    return wrap('❌ batch_add 需要 nodes 数组');
+                }
+                // 自动填充默认值 — AI 只需填 id+label+description
+                const fullNodes = decoded.nodes.map((n) => ({
+                    id: n.id,
+                    label: n.label,
+                    nodeType: n.nodeType || 'process',
+                    domain: n.domain || 'system',
+                    input: n.input || [],
+                    output: n.output || [],
+                    description: n.description || '',
+                    affiliation: n.affiliation || 'root',
+                    boundDocs: [],
+                    boundFiles: [],
+                    boundDirs: [],
+                    boundTasks: [],
+                    subFlowchart: null,
+                    position: null,
+                    versions: [],
+                    lastUpdated: '',
+                    lastQueried: '',
+                }));
+                const fullEdges = (decoded.edges || []).map((e) => ({
+                    from: e.from,
+                    to: e.to,
+                    label: e.label || null,
+                    edgeType: e.edgeType || 'call',
+                }));
+                const result = await client().batchAddToFlowchart(chartId, fullNodes, fullEdges);
+                // 构建报告
+                let report = `✅ 批量操作完成 [${chartId}]\n`;
+                report += `  添加: ${result.addedNodes.length}节点 ${result.addedEdges}连线\n`;
+                if (result.failedNodes.length > 0) {
+                    report += `\n❌ 失败节点:\n`;
+                    result.failedNodes.forEach(([id, reason]) => {
+                        report += `  • ${id}: ${reason}\n`;
+                    });
+                }
+                if (result.failedEdges.length > 0) {
+                    report += `\n❌ 失败连线:\n`;
+                    result.failedEdges.forEach(([from, to, reason]) => {
+                        report += `  • ${from} → ${to}: ${reason}\n`;
+                    });
+                }
+                if (result.orphanedNodes.length > 0) {
+                    report += `\n⚠️ 孤立节点 (无任何连线):\n`;
+                    result.orphanedNodes.forEach(id => {
+                        report += `  • ${id}\n`;
+                    });
+                }
+                else {
+                    report += `\n✅ 无孤立节点`;
+                }
+                return wrap(report);
+            }
+            case 'orphans': {
+                const orphans = await client().getFlowchartOrphans();
+                if (!orphans || orphans.length === 0) {
+                    return wrap('✅ 无孤立文档 — 所有文档均已绑定到流程图节点');
+                }
+                const list = orphans
+                    .map(o => `• ${o.docPath}${o.docSummary ? ` — ${o.docSummary}` : ''}`)
+                    .join('\n');
+                return wrap(`⚠️ 发现 ${orphans.length} 个孤立文档 (未绑定到任何流程图节点):\n\n${list}\n\n💡 使用 kg_doc(update, bindTo: "节点ID") 绑定`);
+            }
+            case 'health': {
+                const health = await client().getFlowchartHealth();
+                if (!health || health.length === 0) {
+                    return wrap('📊 暂无节点健康数据');
+                }
+                const items = health;
+                const stale = items.filter(h => h.status === 'stale');
+                const active = items.filter(h => h.status === 'active');
+                const normal = items.filter(h => h.status === 'normal');
+                let report = `📊 知识冷热分布 (${items.length}节点):\n`;
+                report += `  🟢 active (7天内查询): ${active.length}\n`;
+                report += `  🟡 normal (30天内): ${normal.length}\n`;
+                report += `  🔴 stale (30天+未查询): ${stale.length}\n`;
+                if (stale.length > 0) {
+                    report += `\n🔴 冷知识节点:\n`;
+                    stale.forEach(h => {
+                        report += `  • ${h.nodeLabel} [${h.chartId}/${h.nodeId}] — ${h.daysSinceQuery}天未查询\n`;
+                    });
+                }
+                return wrap(report);
+            }
+            case 'bind':
+            case 'unbind': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId)
+                    return wrap(`❌ ${decoded.action} 需要 nodeId`);
+                const chart = await client().getFlowchart(chartId);
+                if (!chart)
+                    return wrap(`❌ 流程图 "${chartId}" 不存在`);
+                const node = chart.nodes?.find((n) => n.id === decoded.nodeId);
+                if (!node)
+                    return wrap(`❌ 节点 "${decoded.nodeId}" 不存在于流程图 "${chartId}"`);
+                const isBind = decoded.action === 'bind';
+                const changes = [];
+                const modify = (items, field, label) => {
+                    if (!items || items.length === 0)
+                        return;
+                    if (!node[field])
+                        node[field] = [];
+                    if (isBind) {
+                        let added = 0;
+                        for (const item of items) {
+                            if (!node[field].includes(item)) {
+                                node[field].push(item);
+                                added++;
+                            }
+                        }
+                        if (added > 0)
+                            changes.push(`+${added} ${label}`);
+                    }
+                    else {
+                        const before = node[field].length;
+                        node[field] = node[field].filter((x) => !items.includes(x));
+                        const removed = before - node[field].length;
+                        if (removed > 0)
+                            changes.push(`-${removed} ${label}`);
+                    }
+                };
+                modify(decoded.files, 'boundFiles', '文件');
+                modify(decoded.dirs, 'boundDirs', '目录');
+                modify(decoded.docs, 'boundDocs', '文档');
+                modify(decoded.tasks, 'boundTasks', '任务');
+                if (changes.length === 0) {
+                    return wrap(`ℹ️ 无变更 — 请提供 files/dirs/docs/tasks 参数`);
+                }
+                await client().saveFlowchart(chartId, chart);
+                // P2: 双向同步 — 更新参考文档的 adoptedBy
+                const docsList = decoded.docs;
+                if (docsList && docsList.length > 0) {
+                    const nodeId = decoded.nodeId;
+                    for (const docPath of docsList) {
+                        try {
+                            const doc = await client().getDoc(docPath);
+                            if (!doc?.content)
+                                continue;
+                            const content = doc.content;
+                            // 解析 frontmatter
+                            if (!content.startsWith('---'))
+                                continue;
+                            const endIdx = content.indexOf('---', 3);
+                            if (endIdx === -1)
+                                continue;
+                            const yaml = content.slice(3, endIdx);
+                            const body = content.slice(endIdx + 3);
+                            // 提取现有 adoptedBy
+                            const adoptedMatch = yaml.match(/adoptedBy:\s*\[(.*?)\]/);
+                            let adopted = [];
+                            if (adoptedMatch) {
+                                adopted = adoptedMatch[1].split(',').map(s => s.trim()).filter(Boolean);
+                            }
+                            // 修改 adoptedBy
+                            if (isBind) {
+                                if (!adopted.includes(nodeId))
+                                    adopted.push(nodeId);
+                            }
+                            else {
+                                adopted = adopted.filter(id => id !== nodeId);
+                            }
+                            // 重建 frontmatter
+                            const newAdoptedLine = `adoptedBy: [${adopted.join(', ')}]`;
+                            let newYaml;
+                            if (adoptedMatch) {
+                                newYaml = yaml.replace(/adoptedBy:\s*\[.*?\]/, newAdoptedLine);
+                            }
+                            else {
+                                newYaml = yaml.trimEnd() + '\n' + newAdoptedLine + '\n';
+                            }
+                            const newContent = `---${newYaml}---${body}`;
+                            await client().updateDoc(docPath, { content: newContent });
+                        }
+                        catch { /* 单个文档同步失败不阻断 */ }
+                    }
+                }
+                const icon = isBind ? '🔗' : '⛓️';
+                return wrap(`${icon} ${isBind ? '绑定' : '解绑'}完成 [${decoded.nodeId}]: ${changes.join(', ')}`);
+            }
+            default:
+                return wrap(`❌ 未知 action: ${decoded.action}`);
+        }
+    }));
+}

package/dist/tools/index.d.ts

@@ -1,13 +1,14 @@
 /**
  * MCP 工具注册入口
- * 18 个工具, 7 个子模块
+ * 14 个工具, 7 个子模块
  *
- * 🔗 初始化:   kg_init                       (1个)
- * 📊 导航:     kg_status, kg_tree          (2个)
- * 📚 知识:     kg_doc, kg_projects, kg_rules (3个)
- * 📝 工作流:   kg_task, kg_files, kg_discuss (3个)
- * 🔬 代码分析: code_scan, code_query, code_impact, code_context, code_path, code_smart_context, code_full_path (7个)
- * 🏛️ 协作:    kg_meeting                    (1个)
+ * 🔗 初始化:   kg_init                                           (1个)
+ * 📊 导航:     kg_status, kg_tree                                (2个)
+ * 📚 知识:     kg_doc(参考文档), kg_projects, kg_rules            (3个)
+ * 📝 工作流:   kg_task(任务记录), kg_files, kg_discuss(讨论区)     (3个)
+ * 🔀 关系核心: kg_flowchart(逻辑流程图 — 关系型知识锚点)           (1个)
+ * 🔬 代码分析: code_scan, code_smart_context, code_full_path      (3个)
+ * 🏛️ 协作:    kg_meeting                                         (1个)
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function registerTools(server: McpServer, projectId: string, user: string, onProjectChange?: (newProjectId: string, newApiUrl: string) => void): void;

package/dist/tools/index.js

@@ -1,13 +1,14 @@
 /**
  * MCP 工具注册入口
- * 18 个工具, 7 个子模块
+ * 14 个工具, 7 个子模块
  *
- * 🔗 初始化:   kg_init                       (1个)
- * 📊 导航:     kg_status, kg_tree          (2个)
- * 📚 知识:     kg_doc, kg_projects, kg_rules (3个)
- * 📝 工作流:   kg_task, kg_files, kg_discuss (3个)
- * 🔬 代码分析: code_scan, code_query, code_impact, code_context, code_path, code_smart_context, code_full_path (7个)
- * 🏛️ 协作:    kg_meeting                    (1个)
+ * 🔗 初始化:   kg_init                                           (1个)
+ * 📊 导航:     kg_status, kg_tree                                (2个)
+ * 📚 知识:     kg_doc(参考文档), kg_projects, kg_rules            (3个)
+ * 📝 工作流:   kg_task(任务记录), kg_files, kg_discuss(讨论区)     (3个)
+ * 🔀 关系核心: kg_flowchart(逻辑流程图 — 关系型知识锚点)           (1个)
+ * 🔬 代码分析: code_scan, code_smart_context, code_full_path      (3个)
+ * 🏛️ 协作:    kg_meeting                                         (1个)
  */
 import { createContext } from './shared.js';
 import { registerInitTool } from './init.js';
@@ -20,6 +21,7 @@ import { registerFileTools } from './files.js';
 import { registerDiscussionTools } from './discussion.js';
 import { registerAnalyzerTools } from './analyzer.js';
 import { registerMeetingTools } from './meeting.js';
+import { registerFlowchartTools } from './flowchart.js';
 export function registerTools(server, projectId, user, onProjectChange) {
     // 创建共享可变上下文 — 所有工具捕获此对象引用
     const ctx = createContext(projectId, user);
@@ -35,8 +37,10 @@ export function registerTools(server, projectId, user, onProjectChange) {
     registerTaskTools(server, ctx);
     registerFileTools(server);
     registerDiscussionTools(server, ctx);
-    // 🔬 代码分析 (code_scan, code_query, code_impact, code_context, code_path, code_smart_context, code_full_path)
+    // 🔬 代码分析 (code_scan, code_smart_context, code_full_path)
     registerAnalyzerTools(server, ctx);
     // 🏛️ 多AI协作 (kg_meeting)
     registerMeetingTools(server, ctx);
+    // 🔀 流程图 (kg_flowchart)
+    registerFlowchartTools(server, ctx);
 }

package/dist/tools/rules.js

@@ -10,7 +10,7 @@ import { wrap, safeTool, crossPrefix } from './shared.js';
 export function registerRuleTools(server, ctx) {
     const client = () => getClient();
     server.tool('kg_rules', '📏 项目规则管理 — 读取或保存代码风格、审查规则等。action: get(读取规则)|save(保存规则)|get_meta(读取触发配置)|save_meta(保存触发配置)', {
-        action: z.enum(['get', 'save', 'get_meta', 'save_meta'])
+        action: z.enum(['get', 'save', 'get_meta', 'save_meta', 'delete'])
             .describe('操作类型'),
         ruleType: z.string().optional()
             .describe('规则类型(如 userStyles, codeStyle, reviewRules)。get/save 时使用，不传则获取全部'),
@@ -96,6 +96,24 @@ export function registerRuleTools(server, ctx) {
                     return wrap('❌ 保存失败');
                 return wrap(`✅ 触发配置已保存 (更新${Object.keys(decoded.meta).length}个类型, 共${Object.keys(merged).length}个类型)`);
             }
+            case 'delete': {
+                if (!decoded.ruleType)
+                    return wrap('❌ delete 需要 ruleType');
+                if (!decoded.rules || decoded.rules.length === 0)
+                    return wrap('❌ delete 需要 rules 数组(要删除的规则内容)');
+                const existing = await client().getRulesApi(decoded.ruleType);
+                const toDelete = new Set(decoded.rules.map((r) => r.trim()));
+                const filtered = existing.filter((r) => !toDelete.has(r.trim()));
+                const removed = existing.length - filtered.length;
+                if (removed === 0)
+                    return wrap('ℹ️ 未找到匹配的规则');
+                const success = await client().saveRulesApi(decoded.ruleType, filtered);
+                if (!success)
+                    return wrap('❌ 删除失败');
+                const meta = await client().getRulesMeta();
+                const label = meta[decoded.ruleType]?.label || decoded.ruleType;
+                return wrap(`✅ ${label}: 已删除${removed}条, 剩余${filtered.length}条`);
+            }
             default:
                 return wrap(`❌ 未知 action: ${decoded.action}`);
         }

package/dist/tools/tasks.d.ts

@@ -1,6 +1,6 @@
 /**
- * 📝 kg_task (4→1)
- * 合并: task_create, task_get, task_update, task_archive
+ * 📝 kg_task (4→1) — 极简任务管理
+ * AI 只需说人话写内容，后端负责所有格式化、分类、时间戳
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type McpContext } from './shared.js';