@ppdocs/mcp 3.2.36 → 3.2.37

package/README.md

@@ -8,6 +8,8 @@
 
 ppdocs MCP 是一个 [Model Context Protocol](https://modelcontextprotocol.io/) 服务器，让 Claude 能够在对话中构建和查询项目知识图谱。
 
+当前 MCP 采用 `flowchart-first` 模型：节点、关系、绑定文件、任务关联和节点文档统一收敛到 `kg_flowchart(action:"...")`，不再维护独立的 `kg_doc` / `kg_search` / `kg_create_node` 一组旧接口。
+
 ```
 ┌─────────────┐     MCP      ┌─────────────┐    HTTP    ┌─────────────┐
 │  Claude AI  │ ──────────── │ @ppdocs/mcp │ ────────── │ ppdocs 桌面 │
@@ -105,28 +107,55 @@ npx @ppdocs/mcp init -p <projectId> -k <key> --codex
 
 ## 工具列表
 
-### 知识图谱工具
+### 核心工具
 
 | 工具 | 说明 |
 |------|------|
-| `kg_create_node` | 创建知识节点 |
-| `kg_update_node` | 更新节点内容 |
-| `kg_delete_node` | 删除节点 |
-| `kg_lock_node` | 锁定节点 (AI 只能锁定，解锁需前端手动) |
-| `kg_list_nodes` | 列出节点 (支持 status/edges 过滤，maxEdges=0 查孤立节点) |
-| `kg_search` | 关键词搜索 |
-| `kg_find_path` | 查找依赖路径 |
-| `kg_get_relations` | 获取节点关系 |
+| `kg_init` | 初始化项目连接与上下文 |
+| `kg_status` | 查看项目仪表盘与流程图概况 |
+| `kg_flowchart` | 统一的知识图谱入口，负责查询、更新、关系分析 |
+| `kg_rules` | 规则管理 |
+| `kg_task` | 任务管理 |
+| `kg_files` | 项目文件读写/上传下载 |
+| `kg_discuss` | 讨论区 |
+| `kg_meeting` | 多 AI 协作会议 |
+| `code_scan` | 代码扫描 |
+| `code_smart_context` | 获取符号的智能上下文 |
+| `code_full_path` | 获取两个符号之间的全路径 |
+
+### `kg_flowchart` actions
+
+| action | 说明 |
+|------|------|
+| `list` | 列出所有流程图 |
+| `get` | 获取指定流程图的节点与连线 |
+| `search` | 按关键词搜索节点、节点文档与绑定资源 |
+| `get_relations` | 查看某节点的入边/出边关系 |
+| `find_path` | 查找两个节点之间的有向路径 |
+| `get_node` | 获取节点详情、关联层级、绑定资源与文档 |
+| `update_node` | 更新节点信息并追加节点文档版本 |
+| `delete_node` | 删除节点 |
+| `batch_add` | 批量新增节点与连线 |
+| `bind` / `unbind` | 绑定或解绑文件、目录、文档、任务 |
+| `orphans` | 检查孤立参考文档 |
+| `health` | 查看节点健康度 |
+| `create_chart` | 创建子图并绑定到父节点 |
+| `delete_chart` | 删除子图 |
+
+### 常用示例
 
-### 任务管理工具
+```bash
+# 搜索相关节点
+kg_flowchart(action:"search", query:"flowchart storage")
 
-| 工具 | 说明 |
-|------|------|
-| `task_create` | 创建开发任务 |
-| `task_list` | 列出任务 |
-| `task_get` | 获取任务详情 |
-| `task_add_log` | 添加进度日志 |
-| `task_complete` | 完成任务并归档 |
+# 查看节点详情
+kg_flowchart(action:"get_node", chartId:"main", nodeId:"n_storage", expand:2, includeDoc:true, includeFiles:true)
+
+# 追加节点文档
+kg_flowchart(action:"update_node", chartId:"main", nodeId:"n_storage",
+  docSummary:"补充存储层职责",
+  docContent:"## 职责\n...\n## 关键流程\n...")
+```
 
 ---
 
@@ -178,18 +207,15 @@ npx @ppdocs/mcp init -p <projectId> -k <key> --codex
 
 ## 更新日志
 
-### v2.6.9
-- ✨ `kg_list_nodes` 支持 status/minEdges/maxEdges 过滤
-- 🗑️ 移除 `kg_find_orphans` (用 `kg_list_nodes(maxEdges: 0)` 替代)
+### v3.2.36
+- 统一为 `flowchart-first` MCP 接口模型
+- `kg_flowchart` 新增 `search` / `get_relations` / `find_path`
+- 文档与模板改为使用 `kg_flowchart(action:"...")`，不再引用旧 `kg_doc` / `kg_search` 等独立接口
 
 ### v2.5.0
-- ✨ 新增 CLI init 命令，自动安装工作流模板
-- ✨ 支持 Codex 模式 (--codex)
-- 📦 构建时自动复制模板
-
-### v2.4.0
-- 🛡️ `kg_lock_node` 只能锁定，解锁需前端手动操作
-- ⚡ 后端自动记录操作日志
+- 新增 CLI init 命令，自动安装工作流模板
+- 支持 Codex 模式 (`--codex`)
+- 构建时自动复制模板
 
 ### v2.3.0
 - 新增任务管理功能

package/dist/tools/flowchart.js

@@ -135,14 +135,130 @@ function collectNeighborLayers(chart, startNodeId, maxDepth) {
     }
     return layers;
 }
+function normalizeText(value) {
+    return (value ?? '').trim().toLowerCase();
+}
+function scoreNodeMatch(node, terms) {
+    const label = normalizeText(node.label);
+    const id = normalizeText(node.id);
+    const description = normalizeText(node.description);
+    const nodeType = normalizeText(node.nodeType);
+    const domain = normalizeText(node.domain);
+    const inputs = ensureArray(node.input).join(' ').toLowerCase();
+    const outputs = ensureArray(node.output).join(' ').toLowerCase();
+    const files = ensureArray(node.boundFiles).join(' ').toLowerCase();
+    const dirs = ensureArray(node.boundDirs).join(' ').toLowerCase();
+    const docs = ensureArray(node.boundDocs).join(' ').toLowerCase();
+    const tasks = ensureArray(node.boundTasks).join(' ').toLowerCase();
+    const docEntries = (node.docEntries ?? [])
+        .flatMap((entry) => [entry.summary, entry.content])
+        .join(' ')
+        .toLowerCase();
+    let score = 0;
+    let matchedTerms = 0;
+    for (const term of terms) {
+        let matched = false;
+        if (label === term || id === term) {
+            score += 120;
+            matched = true;
+        }
+        else if (label.includes(term)) {
+            score += 80;
+            matched = true;
+        }
+        else if (id.includes(term)) {
+            score += 70;
+            matched = true;
+        }
+        if (description.includes(term)) {
+            score += 40;
+            matched = true;
+        }
+        if (nodeType.includes(term) || domain.includes(term)) {
+            score += 25;
+            matched = true;
+        }
+        if (inputs.includes(term) || outputs.includes(term)) {
+            score += 20;
+            matched = true;
+        }
+        if (files.includes(term) || dirs.includes(term)) {
+            score += 18;
+            matched = true;
+        }
+        if (docs.includes(term) || tasks.includes(term)) {
+            score += 15;
+            matched = true;
+        }
+        if (docEntries.includes(term)) {
+            score += 10;
+            matched = true;
+        }
+        if (matched) {
+            matchedTerms += 1;
+        }
+    }
+    if (matchedTerms === 0) {
+        return 0;
+    }
+    return score + matchedTerms * 100;
+}
+function collectNodeRelations(chart, nodeId) {
+    const nodeMap = new Map(chart.nodes.map((node) => [node.id, node]));
+    const incoming = chart.edges
+        .filter((edge) => edge.to === nodeId)
+        .map((edge) => ({ edge, node: nodeMap.get(edge.from) }));
+    const outgoing = chart.edges
+        .filter((edge) => edge.from === nodeId)
+        .map((edge) => ({ edge, node: nodeMap.get(edge.to) }));
+    return { incoming, outgoing };
+}
+function findDirectedPath(chart, fromId, toId) {
+    if (fromId === toId) {
+        return [];
+    }
+    const visited = new Set([fromId]);
+    const queue = [fromId];
+    const prev = new Map();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const nextEdges = chart.edges.filter((edge) => edge.from === current);
+        for (const edge of nextEdges) {
+            if (visited.has(edge.to)) {
+                continue;
+            }
+            visited.add(edge.to);
+            prev.set(edge.to, { parent: current, edge });
+            if (edge.to === toId) {
+                const path = [];
+                let cursor = toId;
+                while (cursor !== fromId) {
+                    const step = prev.get(cursor);
+                    if (!step) {
+                        return null;
+                    }
+                    path.push(step.edge);
+                    cursor = step.parent;
+                }
+                return path.reverse();
+            }
+            queue.push(edge.to);
+        }
+    }
+    return null;
+}
 export function registerFlowchartTools(server, _ctx) {
     const client = () => getClient();
-    server.tool('kg_flowchart', 'Logical flowchart operations: list|get|get_node|update_node|delete_node|batch_add|bind|unbind|orphans|health|create_chart|delete_chart', {
+    server.tool('kg_flowchart', 'Logical flowchart operations: list|get|search|get_relations|find_path|get_node|update_node|delete_node|batch_add|bind|unbind|orphans|health|create_chart|delete_chart', {
         action: z
-            .enum(['list', 'get', 'get_node', 'update_node', 'delete_node', 'batch_add', 'bind', 'unbind', 'orphans', 'health', 'create_chart', 'delete_chart'])
+            .enum(['list', 'get', 'search', 'get_relations', 'find_path', 'get_node', 'update_node', 'delete_node', 'batch_add', 'bind', 'unbind', 'orphans', 'health', 'create_chart', 'delete_chart'])
             .describe('action type'),
         chartId: z.string().optional().describe('chart id, default main'),
-        nodeId: z.string().optional().describe('node id for get_node/update_node/delete_node/bind/unbind'),
+        nodeId: z.string().optional().describe('node id for get_relations/get_node/update_node/delete_node/bind/unbind'),
+        query: z.string().optional().describe('search query for action=search'),
+        fromId: z.string().optional().describe('start node id for action=find_path'),
+        toId: z.string().optional().describe('target node id for action=find_path'),
+        limit: z.number().optional().describe('search result limit, default 10'),
         expand: z.number().optional().describe('get_node expansion depth, default 3'),
         includeDocs: z.boolean().optional().describe('show bound docs in get_node, default true'),
         includeTasks: z.boolean().optional().describe('show bound tasks in get_node, default true'),
@@ -200,6 +316,131 @@ export function registerFlowchartTools(server, _ctx) {
                 ].filter((line) => line.length > 0);
                 return wrap(lines.join('\n'));
             }
+            case 'search': {
+                const rawQuery = decoded.query?.trim();
+                if (!rawQuery) {
+                    return wrap('search requires query.');
+                }
+                const terms = rawQuery
+                    .toLowerCase()
+                    .split(/\s+/)
+                    .filter(Boolean);
+                const charts = decoded.chartId
+                    ? [(await client().getFlowchart(decoded.chartId))].filter((item) => Boolean(item))
+                    : await (async () => {
+                        const briefs = (await client().listFlowcharts());
+                        const loaded = await Promise.all(briefs.map(async (brief) => (await client().getFlowchart(brief.id))));
+                        return loaded.filter((item) => Boolean(item));
+                    })();
+                const matches = charts
+                    .flatMap((chart) => chart.nodes.map((rawNode) => {
+                    const node = ensureNodeShape(rawNode);
+                    return {
+                        chart,
+                        node,
+                        score: scoreNodeMatch(node, terms),
+                    };
+                }))
+                    .filter((item) => item.score > 0)
+                    .sort((a, b) => b.score - a.score)
+                    .slice(0, Math.max(1, decoded.limit ?? 10));
+                if (matches.length === 0) {
+                    return wrap(`No flowchart nodes matched query: ${rawQuery}`);
+                }
+                const lines = [
+                    `Search results for: ${rawQuery}`,
+                    '',
+                    ...matches.map(({ chart, node }) => {
+                        const badges = [
+                            node.domain ? `domain=${node.domain}` : '',
+                            node.nodeType ? `type=${node.nodeType}` : '',
+                            node.subFlowchart ? `sub=${node.subFlowchart}` : '',
+                        ].filter(Boolean);
+                        const suffix = badges.length > 0 ? ` | ${badges.join(' ')}` : '';
+                        const description = node.description ? ` | ${node.description}` : '';
+                        return `- ${node.label} [${chart.id}/${node.id}]${suffix}${description}`;
+                    }),
+                ];
+                return wrap(lines.join('\n'));
+            }
+            case 'get_relations': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId) {
+                    return wrap('get_relations requires nodeId.');
+                }
+                const chart = (await client().getFlowchart(chartId));
+                if (!chart) {
+                    return wrap(`Flowchart not found: ${chartId}`);
+                }
+                const nodeMap = new Map(chart.nodes.map((node) => [node.id, node]));
+                const node = nodeMap.get(decoded.nodeId);
+                if (!node) {
+                    return wrap(`Node not found: ${decoded.nodeId} in ${chartId}`);
+                }
+                const relations = collectNodeRelations(chart, decoded.nodeId);
+                const lines = [
+                    `Relations: ${node.label} [${chartId}/${node.id}]`,
+                    `Incoming: ${relations.incoming.length}`,
+                    `Outgoing: ${relations.outgoing.length}`,
+                ];
+                if (relations.incoming.length > 0) {
+                    lines.push('', 'Incoming edges:');
+                    relations.incoming.forEach(({ edge, node: source }) => {
+                        lines.push(`- ${source?.label ?? edge.from} [${edge.from}] -> ${node.label} [${edge.to}]${edge.label ? ` (${edge.label})` : ''}${edge.edgeType ? ` [${edge.edgeType}]` : ''}`);
+                    });
+                }
+                if (relations.outgoing.length > 0) {
+                    lines.push('', 'Outgoing edges:');
+                    relations.outgoing.forEach(({ edge, node: target }) => {
+                        lines.push(`- ${node.label} [${edge.from}] -> ${target?.label ?? edge.to} [${edge.to}]${edge.label ? ` (${edge.label})` : ''}${edge.edgeType ? ` [${edge.edgeType}]` : ''}`);
+                    });
+                }
+                const linked = new Set([
+                    ...relations.incoming.map(({ edge }) => edge.from),
+                    ...relations.outgoing.map(({ edge }) => edge.to),
+                ]);
+                if (linked.size > 0) {
+                    lines.push('', `Linked nodes: ${linked.size}`);
+                }
+                return wrap(lines.join('\n'));
+            }
+            case 'find_path': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.fromId || !decoded.toId) {
+                    return wrap('find_path requires fromId and toId.');
+                }
+                const chart = (await client().getFlowchart(chartId));
+                if (!chart) {
+                    return wrap(`Flowchart not found: ${chartId}`);
+                }
+                const nodeMap = new Map(chart.nodes.map((node) => [node.id, node]));
+                const fromNode = nodeMap.get(decoded.fromId);
+                const toNode = nodeMap.get(decoded.toId);
+                if (!fromNode || !toNode) {
+                    return wrap(`find_path could not resolve nodes in ${chartId}: from=${decoded.fromId} to=${decoded.toId}`);
+                }
+                const path = findDirectedPath(chart, decoded.fromId, decoded.toId);
+                if (path === null) {
+                    return wrap(`No directed path found: [${chartId}/${decoded.fromId}] -> [${chartId}/${decoded.toId}]`);
+                }
+                if (path.length === 0) {
+                    return wrap(`Path resolved: ${fromNode.label} [${fromNode.id}] (same node)`);
+                }
+                const lines = [
+                    `Directed path: ${fromNode.label} [${fromNode.id}] -> ${toNode.label} [${toNode.id}]`,
+                    `Hops: ${path.length}`,
+                    '',
+                ];
+                let current = fromNode;
+                path.forEach((edge, index) => {
+                    const nextNode = nodeMap.get(edge.to);
+                    lines.push(`${index + 1}. ${current.label} [${edge.from}] -> ${nextNode?.label ?? edge.to} [${edge.to}]${edge.label ? ` (${edge.label})` : ''}${edge.edgeType ? ` [${edge.edgeType}]` : ''}`);
+                    if (nextNode) {
+                        current = nextNode;
+                    }
+                });
+                return wrap(lines.join('\n'));
+            }
             case 'get_node': {
                 const chartId = decoded.chartId || 'main';
                 if (!decoded.nodeId) {

package/dist/tools/rules.d.ts

@@ -1,7 +1,6 @@
 /**
- * 📏 kg_rules (6→1)
- * 合并: kg_get_rules, kg_save_rules, kg_get_rules_meta, kg_save_rules_meta
- * 删除: kg_get_global_rules_meta, kg_save_global_rules_meta (管理员操作)
+ * 📏 kg_rules
+ * 统一规则入口: get | save | get_meta | save_meta | delete
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type McpContext } from './shared.js';

package/dist/tools/rules.js

@@ -1,7 +1,6 @@
 /**
- * 📏 kg_rules (6→1)
- * 合并: kg_get_rules, kg_save_rules, kg_get_rules_meta, kg_save_rules_meta
- * 删除: kg_get_global_rules_meta, kg_save_global_rules_meta (管理员操作)
+ * 📏 kg_rules
+ * 统一规则入口: get | save | get_meta | save_meta | delete
  */
 import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ppdocs/mcp",
-  "version": "3.2.36",
+  "version": "3.2.37",
   "description": "ppdocs MCP Server - Knowledge Graph for Claude",
   "type": "module",
   "main": "dist/index.js",

package/templates/commands/init.md

@@ -4,7 +4,7 @@ description: 初始化知识图谱：100%扫描代码库，为每个模块创建
 
 # /init 项目初始化
 
-执行 `task_create("项目初始化: [项目名]")` → 递归扫描全部代码文件 → 逐文件审查创建节点 → 每处理5个文件调用 `task_add_log(progress)` 同步进度 → 全部完成后 `task_complete` 输出统计报告
+执行 `kg_task(action:"create", title:"项目初始化: [项目名]")` → 递归扫描全部代码文件 → 逐文件审查创建节点 → 每处理5个文件调用 `kg_task(action:"update", log_type:"progress")` 同步进度 → 全部完成后 `kg_task(action:"archive")` 输出统计报告
 
 ## 扫描规则
 
@@ -84,11 +84,11 @@ flowchart TB
 
 ## 进度同步
 
-每处理5个文件或完成1个目录后，调用 `task_add_log("progress", "已处理: [文件列表], 创建节点: N个")`
+每处理5个文件或完成1个目录后，调用 `kg_task(action:"update", log_type:"progress", content:"已处理: [文件列表], 创建节点: N个")`
 
 ## 完成输出
 
-`task_complete` 时输出完整统计：
+`kg_task(action:"archive")` 时输出完整统计：
 
 ```markdown
 | 统计项 | 数量 |

package/templates/commands/pp/diagnose.md

@@ -19,8 +19,8 @@
 
 **1.1 建立全景**
 ```
-kg_tree()                          → 知识全景图
-kg_flowchart(action:"get")         → 主图结构 (8个模块 + 连线)
+kg_flowchart(action:"list")        → 知识图谱列表
+kg_flowchart(action:"get")         → 主图结构 (模块 + 连线)
 kg_rules(action:"get", ruleType:"errorAnalysis") → 错误分析规则
 ```
 
@@ -162,7 +162,7 @@ L2: 2个间接调用方可能受影响
 
 | 阶段 | 工具 | 用途 |
 |:---|:---|:---|
-| 锚定 | `kg_tree()` | 全景鸟瞰 |
+| 锚定 | `kg_flowchart(list/get)` | 全景鸟瞰 |
 | 锚定 | `kg_flowchart(get)` | 主图结构 |
 | 锚定 | `kg_rules(get)` | 分析规则 |
 | 下探 | `kg_flowchart(get_node, expand:N)` | 节点详情+上下游 |

package/templates/commands/pp/init.md

@@ -27,10 +27,10 @@
 
 ### Phase 0: 环境准备
 ```
-kg_init()              → 连接项目上下文
-kg_status()            → 查看仪表盘 (文档数/任务数/状态)
-kg_tree()              → 已有知识全景图
-kg_flowchart(action:"list")  → 已有流程图列表
+kg_init()                   → 连接项目上下文
+kg_status()                 → 查看仪表盘 (流程图/任务/状态)
+kg_flowchart(action:"list") → 已有流程图列表
+kg_flowchart(action:"get")  → 主图结构总览
 ```
 如果已有图谱 → 提示用户选择: 增量补充 or 重建
 
@@ -125,27 +125,18 @@ kg_flowchart(action:"bind", nodeId:"n_graph_store",
   dirs:["src-tauri/src/storage/"])
 ```
 
-**3.2 创建参考文档 (遵循5分类规范)**
+**3.2 写入节点内置文档 (`docEntries`)**
 ```
-文档分类:
-  /模块/后端/存储层      → 对应 n_storage
-  /模块/后端/graph_store → 对应 n_graph_store
-  /模块/前端/FlowchartView → 对应 n_flowchart_view
-  /架构/事件驱动         → 对应架构决策
-  /功能/知识图谱编辑      → 对应用户功能
-
-kg_doc(action:"create",
-  path:"/模块/后端/graph_store",
-  summary:"项目/文档/规则/搜索的核心存储, JSON持久化",
-  content:"## 职责\n...\n## 公开API\n...\n## 文件路径\n...",
-  bindTo:"n_graph_store")
+kg_flowchart(action:"update_node", chartId:"sub_storage", nodeId:"n_graph_store",
+  docSummary:"项目/规则/流程图数据持久化核心",
+  docContent:"## 职责\n...\n## 公开 API\n...\n## 文件路径\n- src-tauri/src/storage/graph_store.rs")
 ```
 
 ### Phase 4: 健康验证
 ```
 kg_flowchart(action:"orphans")    → 孤立节点 (应为0)
 kg_flowchart(action:"health")     → 冷热分布
-kg_tree()                         → 全景确认文档覆盖
+kg_flowchart(action:"get")        → 全景确认节点覆盖与连线
 kg_status()                       → 最终仪表盘
 ```
 

package/templates/commands/pp/sync.md

@@ -7,7 +7,7 @@
 | **代码即真理** | 代码与图谱冲突时以 Git 状态为准, 强制覆写 |
 | **层级感知** | 变更定位到具体子图层级, 逐层向上验证影响链 |
 | **最小变更** | 只更新有差异的节点/文档, 不做无意义的全量覆写 |
-| **创建即关联** | 新增节点必须 bind 源码 + 创建/关联文档, 无孤立资产 |
+| **创建即关联** | 新增节点必须 bind 源码 + 写入节点文档, 无孤立资产 |
 
 ---
 
@@ -30,9 +30,9 @@
 **1.1 获取图谱现状**
 ```
 kg_init()                        → 确保项目连接
-kg_tree()                        → 文档全景
 kg_flowchart(action:"list")      → 所有流程图
 kg_flowchart(action:"get")       → 主图节点+连线
+kg_flowchart(action:"search", query:"关键词") → 快速定位相关节点
 ```
 
 **1.2 获取代码变更**
@@ -106,12 +106,10 @@ all 模式:
 3. 绑定源码:
    kg_flowchart(action:"bind", nodeId:"n_xxx", files:["src/..."])
 
-4. 创建文档 (遵循5分类):
-   kg_doc(action:"create",
-     path:"/模块/前端/xxx",
-     summary:"一句话职责",
-     content:"## 职责\n...\n## 公开API\n...\n## 文件路径\n...",
-     bindTo:"n_xxx")
+4. 写入节点文档:
+   kg_flowchart(action:"update_node", chartId:目标子图, nodeId:"n_xxx",
+     docSummary:"一句话职责",
+     docContent:"## 职责\n...\n## 公开API\n...\n## 文件路径\n...")
 ```
 
 **3.2 处理 [MOD] — 更新节点**
@@ -126,8 +124,9 @@ all 模式:
      docSummary:"更新后的摘要")
 
 3. 追加版本记录:
-   kg_doc(action:"update", path:"/模块/.../xxx",
-     versions:[{version:当前+0.1, date:"ISO日期", changes:"变更摘要"}])
+   kg_flowchart(action:"update_node", chartId:目标子图, nodeId:"n_xxx",
+     docSummary:"本次变更摘要",
+     docContent:"更新后的详细文档")
 
 4. 检查连线是否需要更新:
    code_context(filePath) → 新的import列表
@@ -142,7 +141,6 @@ all 模式:
 
 选项B - 彻底删除:
   kg_flowchart(action:"delete_node", nodeId:"n_xxx")
-  kg_doc(action:"delete", path:"/模块/.../xxx")
 ```
 
 **3.4 处理 [DRIFT] — 路径漂移**
@@ -177,7 +175,7 @@ kg_task(action:"update", taskId:"当前任务", log_type:"progress",
 ```
 kg_flowchart(action:"orphans")     → 全局孤立节点 (应为0)
 kg_flowchart(action:"health")      → 冷热分布
-kg_tree()                          → 文档覆盖确认
+kg_flowchart(action:"get")         → 节点覆盖确认
 ```
 
 ### Phase 5: 交付报告

package/templates/hooks/SystemPrompt.md

@@ -7,7 +7,7 @@
 | 原则 | 要求 |
 |:---|:---|
 | **知识图谱中心** | 方案制定前检索图谱+代码双重验证；任务结束提示沉淀至图谱 |
-| **任务驱动开发** | 复杂任务必须 `task_create`；过程记录 `task_add_log`；完成 `task_complete` |
+| **任务驱动开发** | 复杂任务必须 `kg_task(action:"create")`；过程记录 `kg_task(action:"update")`；完成 `kg_task(action:"archive")` |
 | **规则引用** | 编码前读 `codeStyle`；测试前读 `testRules`；审查前读 `reviewRules` |
 | **绝对真实性** | 禁用 faker/模拟数据，必须真实环境验证 |
 | **沟通可视化** | 禁纯文字/Mermaid代码；强制 ASCII流程图 + Markdown表格 |
@@ -17,7 +17,7 @@
 
 ## 任务生命周期
 ```
-task_create → task_add_log(progress/issue/solution/reference) → task_complete
+kg_task(action:"create") → kg_task(action:"update", log_type:"progress|issue|solution|reference") → kg_task(action:"archive")
 ```
 | 日志类型 | 用途 | 示例 |
 |:---|:---|:---|
@@ -32,24 +32,24 @@ task_create → task_add_log(progress/issue/solution/reference) → task_complet
 
 ### Step 1: 分析与澄清
 1. 接收需求，识别意图
-2. `kg_search` 检索现有节点/历史坑点 (读取 bugfixes)
-3. `kg_get_rules()` 获取项目规则
+2. `kg_flowchart(action:"search", query:"关键词")` 检索现有节点/历史坑点
+3. `kg_rules(action:"get")` 获取项目规则
 4. 有歧义则列选项供用户选择
 
 **输出**: 需求确认清单 (表格)
 
 ### Step 2: 逻辑设计
 1. 结合图谱+代码设计方案
-2. `kg_get_rules(ruleType:"codeStyle")` 确认编码规范
+2. `kg_rules(action:"get", ruleType:"codeStyle")` 确认编码规范
 3. 检查现有复用函数，拒绝重复建设
-4. 大型任务: `task_create`
+4. 大型任务: `kg_task(action:"create")`
 
 **输出**: ASCII流程图 + 对比表 + 子任务列表
 **里程碑**: 等待用户确认 (不写代码)
 
 ### Step 3: 模块化编码
 **前置**: 用户确认方案
-1. `task_add_log(progress, "开始编码")`
+1. `kg_task(action:"update", log_type:"progress", content:"开始编码")`
 2. 优先编写/更新工具函数，再业务组装
 3. 遵循 codeStyle 规则
 4. 清理现场，无残留代码
@@ -57,19 +57,19 @@ task_create → task_add_log(progress/issue/solution/reference) → task_complet
 **输出**: 结构清晰的代码
 
 ### Step 4: 真实验证
-1. `kg_get_rules(ruleType:"testRules")` 获取测试规则
+1. `kg_rules(action:"get", ruleType:"testRules")` 获取测试规则
 2. 在 `tests/` 对应目录创建测试
 3. 真实环境运行，验证输出
-4. 失败时: `task_add_log(issue, "xxx失败")` → 回溯Step2
+4. 失败时: `kg_task(action:"update", log_type:"issue", content:"xxx失败")` → 回溯Step2
 
 **严禁**: "测试环境所以失败"借口
 
 ### Step 5: 审查与沉淀
-1. `kg_get_rules(ruleType:"reviewRules")` 获取审查规则
+1. `kg_rules(action:"get", ruleType:"reviewRules")` 获取审查规则
 2. 审查目录结构/代码简洁度
-3. 发现BUG → `kg_update_node` 写入 bugfixes
-4. 新逻辑 → `kg_create_node` 或 `kg_update_node` (追加 versions)
-5. `task_complete({summary, difficulties, solutions, references})`
+3. 发现BUG → `kg_flowchart(action:"update_node")` 回写节点说明与文档
+4. 新逻辑 → `kg_flowchart(action:"batch_add")` 新增节点，或 `kg_flowchart(action:"update_node")` 追加文档/版本
+5. `kg_task(action:"archive", summary, difficulties, solutions)`
 
 **输出**: 交付确认 + 图谱更新清单
 
@@ -78,7 +78,7 @@ task_create → task_add_log(progress/issue/solution/reference) → task_complet
 ## 异常处理
 | 场景 | 反应 |
 |:---|:---|
-| Step4 测试失败 | 停止 → 分析日志 → task_add_log(issue) → 回溯Step2 → 修正 → 重测 |
+| Step4 测试失败 | 停止 → 分析日志 → `kg_task(action:"update", log_type:"issue")` → 回溯Step2 → 修正 → 重测 |
 | 发现历史BUG | 读取节点 bugfixes 参考历史方案 |
 | 重复造轮子 | 终止 → 指出现有实现 → 要求复用 |