@ppdocs/mcp 3.2.23 → 3.2.25

package/dist/storage/httpClient.d.ts

@@ -51,6 +51,8 @@ export declare class PpdocsApiClient {
     updateFlowchartNode(chartId: string, nodeId: string, node: unknown, changeDesc?: string): Promise<unknown>;
     /** 原子删除单个节点 (后端自动清理关联边) */
     deleteFlowchartNode(chartId: string, nodeId: string): Promise<unknown>;
+    /** 删除流程图 (后端自动级联删子图+清父节点引用) */
+    deleteFlowchart(chartId: string): Promise<unknown>;
     getFlowchartOrphans(): Promise<unknown[]>;
     getFlowchartHealth(): Promise<unknown[]>;
     /** 列出所有可访问的项目 */

package/dist/storage/httpClient.js

@@ -372,6 +372,12 @@ export class PpdocsApiClient {
             method: 'DELETE'
         });
     }
+    /** 删除流程图 (后端自动级联删子图+清父节点引用) */
+    async deleteFlowchart(chartId) {
+        return this.request(`/flowcharts/${chartId}`, {
+            method: 'DELETE'
+        });
+    }
     async getFlowchartOrphans() {
         return this.request('/flowcharts/orphans');
     }

package/dist/tools/flowchart.js

@@ -24,8 +24,8 @@ const EdgeSchema = z.object({
 });
 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'])
+    server.tool('kg_flowchart', '🔀 逻辑流程图(关系型知识锚点) — action: list|get|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'])
             .describe('操作类型'),
         chartId: z.string().optional()
             .describe('流程图ID (默认"main")'),
@@ -49,6 +49,10 @@ export function registerFlowchartTools(server, ctx) {
         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: 新输出'),
+        subFlowchart: z.string().optional().describe('update_node: 绑定子图ID / create_chart时自动设置'),
+        title: z.string().optional().describe('create_chart: 子图标题'),
+        parentChart: z.string().optional().describe('create_chart: 父图ID (默认main)'),
+        parentNode: z.string().optional().describe('create_chart: 挂载到父图的哪个节点ID'),
         // bind/unbind
         files: z.array(z.string()).optional()
             .describe('源代码文件路径 (bind/unbind)'),
@@ -250,39 +254,46 @@ export function registerFlowchartTools(server, ctx) {
                 const chartId = decoded.chartId || 'main';
                 if (!decoded.nodeId)
                     return wrap('❌ update_node 需要 nodeId');
-                // 构建待更新的节点字段
-                const updates = { id: decoded.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}" 不存在`);
                 const changes = [];
                 if (decoded.label !== undefined) {
-                    updates.label = decoded.label;
+                    node.label = decoded.label;
                     changes.push('label');
                 }
                 if (decoded.description !== undefined) {
-                    updates.description = decoded.description;
+                    node.description = decoded.description;
                     changes.push('description');
                 }
                 if (decoded.nodeType !== undefined) {
-                    updates.nodeType = decoded.nodeType;
+                    node.nodeType = decoded.nodeType;
                     changes.push('nodeType');
                 }
                 if (decoded.domain !== undefined) {
-                    updates.domain = decoded.domain;
+                    node.domain = decoded.domain;
                     changes.push('domain');
                 }
                 if (decoded.input !== undefined) {
-                    updates.input = decoded.input;
+                    node.input = decoded.input;
                     changes.push('input');
                 }
                 if (decoded.output !== undefined) {
-                    updates.output = decoded.output;
+                    node.output = decoded.output;
                     changes.push('output');
                 }
+                if (decoded.subFlowchart !== undefined) {
+                    node.subFlowchart = decoded.subFlowchart;
+                    changes.push('subFlowchart');
+                }
                 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(', ')}`);
+                node.lastUpdated = new Date().toISOString();
+                await client().saveFlowchart(chartId, chart);
+                return wrap(`✅ 节点已更新: ${node.label} [${chartId}/${decoded.nodeId}]\n更新字段: ${changes.join(', ')}`);
             }
             case 'delete_node': {
                 const chartId = decoded.chartId || 'main';
@@ -311,7 +322,7 @@ export function registerFlowchartTools(server, ctx) {
                     boundFiles: [],
                     boundDirs: [],
                     boundTasks: [],
-                    subFlowchart: null,
+                    subFlowchart: n.subFlowchart || null,
                     position: null,
                     versions: [],
                     lastUpdated: '',
@@ -476,6 +487,70 @@ export function registerFlowchartTools(server, ctx) {
                 const icon = isBind ? '🔗' : '⛓️';
                 return wrap(`${icon} ${isBind ? '绑定' : '解绑'}完成 [${decoded.nodeId}]: ${changes.join(', ')}`);
             }
+            case 'create_chart': {
+                const newChartId = decoded.chartId;
+                if (!newChartId)
+                    return wrap('❌ create_chart 需要 chartId (子图ID)');
+                if (newChartId === 'main')
+                    return wrap('❌ 不能创建 main，主图已存在');
+                // 检查是否已存在
+                const existing = await client().getFlowchart(newChartId);
+                if (existing)
+                    return wrap(`❌ 流程图 "${newChartId}" 已存在`);
+                const pChart = decoded.parentChart || 'main';
+                const pNode = decoded.parentNode;
+                // 构建子图数据
+                const subChartData = {
+                    id: newChartId,
+                    title: decoded.title || newChartId,
+                    parentNode: pNode || null,
+                    parentChart: pChart,
+                    nodes: [],
+                    edges: [],
+                };
+                // 如果提供了 nodes/edges，填充进去
+                if (decoded.nodes && decoded.nodes.length > 0) {
+                    subChartData.nodes = 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: '',
+                    }));
+                }
+                if (decoded.edges && decoded.edges.length > 0) {
+                    subChartData.edges = decoded.edges.map(e => ({
+                        from: e.from, to: e.to, label: e.label || null, edgeType: e.edgeType || 'call',
+                    }));
+                }
+                // 保存子图
+                await client().saveFlowchart(newChartId, subChartData);
+                // 自动更新父节点的 subFlowchart 引用
+                if (pNode) {
+                    const parentChart = await client().getFlowchart(pChart);
+                    if (parentChart) {
+                        const parentNodeObj = (parentChart.nodes || []).find((n) => n.id === pNode);
+                        if (parentNodeObj) {
+                            parentNodeObj.subFlowchart = newChartId;
+                            parentNodeObj.lastUpdated = new Date().toISOString();
+                            await client().saveFlowchart(pChart, parentChart);
+                        }
+                    }
+                }
+                const nodeCount = subChartData.nodes.length;
+                return wrap(`✅ 子图已创建: ${decoded.title || newChartId} [${newChartId}]\n父图: ${pChart}${pNode ? ` → 节点: ${pNode}` : ''}\n初始: ${nodeCount}节点`);
+            }
+            case 'delete_chart': {
+                const chartId = decoded.chartId;
+                if (!chartId)
+                    return wrap('❌ delete_chart 需要 chartId');
+                if (chartId === 'main')
+                    return wrap('❌ 不能删除主图 main');
+                // 后端自动级联: 清父节点引用 + 删子图的子图
+                await client().deleteFlowchart(chartId);
+                return wrap(`✅ 流程图已删除 [${chartId}] (子图已级联清理)`);
+            }
             default:
                 return wrap(`❌ 未知 action: ${decoded.action}`);
         }

package/package.json

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