@ppdocs/mcp 3.2.36 → 3.2.38

package/dist/tools/flowchart.js

@@ -135,14 +135,133 @@ 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', '🔀 逻辑流程图 — 项目知识图谱的核心。每个节点代表一个模块/函数/概念，节点可绑定文件、内嵌版本化文档。\n' +
+        '⚡ 开始任何任务前必须先查图谱：search 搜关键词 → get_node 看详情 → 有 subFlowchart 则递归下探。\n' +
+        '📝 完成修改后必须回写：bind 绑定文件 → update_node 更新描述和文档 → 新模块用 batch_add。\n' +
+        'actions: 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 +319,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/index.d.ts

@@ -1,11 +1,11 @@
 /**
  * MCP 工具注册入口
- * 12 个工具, 6 个子模块
+ * 13 个工具, 7 个子模块
  *
  * 🔗 初始化:   kg_init                                           (1个)
  * 📊 导航:     kg_status                                         (1个)
- * 📚 知识:     kg_projects, kg_rules                              (2个)
- * 📝 工作流:   kg_task(任务记录), kg_files, kg_discuss(讨论区)     (3个)
+ * 📚 知识:     kg_projects, kg_workflow                           (2个)
+ * 📝 工作流:   kg_task(任务记录), kg_files, kg_discuss(讨论区), kg_ref (4个)
  * 🔀 关系核心: kg_flowchart(逻辑流程图 — 关系型知识锚点)           (1个)
  * 🔬 代码分析: code_scan, code_smart_context, code_full_path      (3个)
  * 🏛️ 协作:    kg_meeting                                         (1个)

package/dist/tools/index.js

@@ -1,11 +1,11 @@
 /**
  * MCP 工具注册入口
- * 12 个工具, 6 个子模块
+ * 13 个工具, 7 个子模块
  *
  * 🔗 初始化:   kg_init                                           (1个)
  * 📊 导航:     kg_status                                         (1个)
- * 📚 知识:     kg_projects, kg_rules                              (2个)
- * 📝 工作流:   kg_task(任务记录), kg_files, kg_discuss(讨论区)     (3个)
+ * 📚 知识:     kg_projects, kg_workflow                           (2个)
+ * 📝 工作流:   kg_task(任务记录), kg_files, kg_discuss(讨论区), kg_ref (4个)
  * 🔀 关系核心: kg_flowchart(逻辑流程图 — 关系型知识锚点)           (1个)
  * 🔬 代码分析: code_scan, code_smart_context, code_full_path      (3个)
  * 🏛️ 协作:    kg_meeting                                         (1个)
@@ -14,10 +14,11 @@ import { createContext } from './shared.js';
 import { registerInitTool } from './init.js';
 import { registerStatusTool } from './kg_status.js';
 import { registerProjectTools } from './projects.js';
-import { registerRuleTools } from './rules.js';
+import { registerWorkflowTools } from './workflow.js';
 import { registerTaskTools } from './tasks.js';
 import { registerFileTools } from './files.js';
 import { registerDiscussionTools } from './discussion.js';
+import { registerReferenceTools } from './refs.js';
 import { registerAnalyzerTools } from './analyzer.js';
 import { registerMeetingTools } from './meeting.js';
 import { registerFlowchartTools } from './flowchart.js';
@@ -29,11 +30,12 @@ export function registerTools(server, projectId, user, onProjectChange) {
     registerStatusTool(server, ctx);
     // 📚 知识
     registerProjectTools(server, ctx);
-    registerRuleTools(server, ctx);
+    registerWorkflowTools(server, ctx);
     // 📝 工作流
     registerTaskTools(server, ctx);
     registerFileTools(server);
     registerDiscussionTools(server, ctx);
+    registerReferenceTools(server);
     // 🔬 代码分析
     registerAnalyzerTools(server, ctx);
     // 🏛️ 多AI协作

package/dist/tools/refs.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerReferenceTools(server: McpServer): void;

package/dist/tools/refs.js

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { getClient } from '../storage/httpClient.js';
+import { decodeObjectStrings } from '../utils.js';
+import { safeTool, wrap } from './shared.js';
+const linkSchema = z.object({
+    url: z.string(),
+    label: z.string(),
+});
+const fileSchema = z.object({
+    name: z.string(),
+    path: z.string(),
+});
+const adoptedNodeSchema = z.object({
+    chartId: z.string(),
+    nodeId: z.string(),
+    nodeLabel: z.string(),
+});
+export function registerReferenceTools(server) {
+    const client = () => getClient();
+    server.tool('kg_ref', '📎 外部参考 — 管理项目引用的第三方资料、链接、脚本和样例文件。\n' +
+        '涉及参考资料时主动调用：list 查看已有 → get 读详情 → read_file 读附件内容 → save 新增。\n' +
+        'actions: list|get|save|delete|read_file', {
+        action: z.enum(['list', 'get', 'save', 'delete', 'read_file']).describe('操作类型'),
+        id: z.string().optional().describe('参考 ID'),
+        title: z.string().optional().describe('参考标题 (save)'),
+        summary: z.string().optional().describe('Markdown 总结 (save)'),
+        links: z.array(linkSchema).optional().describe('参考链接 (save)'),
+        files: z.array(fileSchema).optional().describe('参考文件 (save)'),
+        scripts: z.array(fileSchema).optional().describe('解析脚本 (save)'),
+        adoptedBy: z.array(adoptedNodeSchema).optional().describe('已采用该参考的节点 (save)'),
+        path: z.string().optional().describe('参考文件路径 (read_file)'),
+    }, async (args) => safeTool(async () => {
+        const decoded = decodeObjectStrings(args);
+        switch (decoded.action) {
+            case 'list': {
+                const refs = await client().listReferences();
+                if (refs.length === 0)
+                    return wrap('当前没有外部参考');
+                const lines = [
+                    `📎 外部参考 (${refs.length})`,
+                    '',
+                    '| ID | 标题 | 链接 | 文件 | 已采用 |',
+                    '|:---|:---|---:|---:|---:|',
+                ];
+                for (const ref of refs) {
+                    lines.push(`| ${ref.id} | ${ref.title} | ${ref.links.length} | ${ref.files.length} | ${ref.adoptedBy.length} |`);
+                }
+                return wrap(lines.join('\n'));
+            }
+            case 'get': {
+                if (!decoded.id)
+                    return wrap('❌ get 需要 id');
+                const ref = await client().getReference(decoded.id);
+                if (!ref)
+                    return wrap(`未找到外部参考: ${decoded.id}`);
+                const lines = [
+                    `# ${ref.title}`,
+                    '',
+                    `- ID: ${ref.id}`,
+                    `- Links: ${ref.links.length}`,
+                    `- Files: ${ref.files.length}`,
+                    `- Scripts: ${ref.scripts.length}`,
+                    `- AdoptedBy: ${ref.adoptedBy.length}`,
+                    '',
+                    ref.summary || '(无摘要)',
+                ];
+                if (ref.links.length > 0) {
+                    lines.push('', '## Links');
+                    for (const link of ref.links) {
+                        lines.push(`- ${link.label}: ${link.url}`);
+                    }
+                }
+                if (ref.files.length > 0) {
+                    lines.push('', '## Files');
+                    for (const file of ref.files) {
+                        lines.push(`- ${file.name}: ${file.path}`);
+                    }
+                }
+                if (ref.scripts.length > 0) {
+                    lines.push('', '## Scripts');
+                    for (const script of ref.scripts) {
+                        lines.push(`- ${script.name}: ${script.path}`);
+                    }
+                }
+                return wrap(lines.join('\n'));
+            }
+            case 'save': {
+                if (!decoded.id)
+                    return wrap('❌ save 需要 id');
+                if (!decoded.title)
+                    return wrap('❌ save 需要 title');
+                const existing = await client().getReference(decoded.id);
+                const now = new Date().toISOString();
+                await client().saveReference({
+                    id: decoded.id,
+                    title: decoded.title,
+                    summary: decoded.summary || existing?.summary || '',
+                    links: decoded.links || existing?.links || [],
+                    files: decoded.files || existing?.files || [],
+                    scripts: decoded.scripts || existing?.scripts || [],
+                    adoptedBy: decoded.adoptedBy || existing?.adoptedBy || [],
+                    createdAt: existing?.createdAt || now,
+                    updatedAt: now,
+                });
+                return wrap(`✅ 外部参考已保存 (${decoded.id})`);
+            }
+            case 'delete': {
+                if (!decoded.id)
+                    return wrap('❌ delete 需要 id');
+                const ok = await client().deleteReference(decoded.id);
+                return wrap(ok ? `✅ 外部参考已删除 (${decoded.id})` : `ℹ️ 未找到外部参考 (${decoded.id})`);
+            }
+            case 'read_file': {
+                if (!decoded.path)
+                    return wrap('❌ read_file 需要 path');
+                const content = await client().readReferenceFile(decoded.path);
+                return wrap(content);
+            }
+            default:
+                return wrap(`❌ 未知 action: ${decoded.action}`);
+        }
+    }));
+}

package/dist/tools/tasks.js

@@ -184,14 +184,14 @@ export function registerTaskTools(server, ctx) {
                     return wrap('归档失败(任务不存在或已归档)');
                 return wrap(`✅ 任务已归档: ${task.title}`);
             }
-            default:
-                return wrap(`❌ 未知 action: ${decoded.action}`);
             case 'delete': {
                 if (!decoded.taskId)
                     return wrap('❌ delete 需要 taskId');
                 const ok = await client().deleteTask(decoded.taskId);
                 return wrap(ok ? `✅ 任务已删除 (ID: ${decoded.taskId})` : '❌ 删除失败(任务不存在)');
             }
+            default:
+                return wrap(`❌ 未知 action: ${decoded.action}`);
         }
     }));
 }

package/dist/tools/workflow.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type McpContext } from './shared.js';
+export declare function registerWorkflowTools(server: McpServer, _ctx: McpContext): void;

package/dist/tools/workflow.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { getClient } from '../storage/httpClient.js';
+import { decodeObjectStrings } from '../utils.js';
+import { safeTool, wrap } from './shared.js';
+export function registerWorkflowTools(server, _ctx) {
+    const client = () => getClient();
+    server.tool('kg_workflow', '📘 文档工作流 — AI 的标准操作手册。每个工作流是一份 Markdown 文档，定义了特定场景下 AI 应该遵循的步骤和规范。\n' +
+        '调用方式：空参数=列出所有工作流；传 id=获取工作流正文；save/delete 需显式 action。\n' +
+        '典型用法：拿到任务后先 kg_workflow() 看有无相关工作流，有则 kg_workflow(id:"xxx") 读取并遵循执行。', {
+        action: z.enum(['list', 'get', 'save', 'delete']).optional().describe('省略时自动推断：无参数=list，有id=get'),
+        id: z.string().optional().describe('工作流 ID'),
+        scope: z.enum(['all', 'global', 'project']).optional().describe('范围：all(默认)|global|project'),
+        title: z.string().optional().describe('标题 (save 必填)'),
+        content: z.string().optional().describe('Markdown 正文 (save 必填)'),
+    }, async (args) => safeTool(async () => {
+        const decoded = decodeObjectStrings(args);
+        const action = decoded.action ?? (decoded.id ? 'get' : 'list');
+        if (!decoded.action && (decoded.title !== undefined || decoded.content !== undefined)) {
+            return wrap('❌ save/delete 需要显式传 action');
+        }
+        switch (action) {
+            case 'list': {
+                const workflows = await client().listWorkflows(decoded.scope ?? 'all');
+                if (workflows.length === 0)
+                    return wrap('当前没有可用文档工作流');
+                const lines = [
+                    `📘 文档工作流列表 (${workflows.length})`,
+                    '',
+                    '| ID | 范围 | 标题 |',
+                    '|:---|:---|:---|',
+                ];
+                for (const w of workflows) {
+                    lines.push(`| ${w.id} | ${w.scope} | ${w.title} |`);
+                }
+                return wrap(lines.join('\n'));
+            }
+            case 'get': {
+                if (!decoded.id)
+                    return wrap('❌ get 需要 id');
+                const doc = await client().getWorkflow(decoded.id, decoded.scope ?? 'all');
+                if (!doc)
+                    return wrap(`未找到工作流: ${decoded.id}`);
+                return wrap([
+                    `# ${doc.title}`,
+                    `> ID: ${doc.id} | 范围: ${doc.scope}`,
+                    '',
+                    doc.content,
+                ].join('\n'));
+            }
+            case 'save': {
+                if (!decoded.id)
+                    return wrap('❌ save 需要 id');
+                if (!decoded.title)
+                    return wrap('❌ save 需要 title');
+                if (!decoded.content)
+                    return wrap('❌ save 需要 content');
+                const doc = await client().saveWorkflow(decoded.id, {
+                    scope: decoded.scope === 'global' ? 'global' : 'project',
+                    title: decoded.title,
+                    description: '',
+                    system: '',
+                    keywords: [],
+                    minHits: 0,
+                    always: false,
+                    content: decoded.content,
+                });
+                return wrap(`✅ 已保存: ${doc.scope}/${doc.id} — ${doc.title}`);
+            }
+            case 'delete': {
+                if (!decoded.id)
+                    return wrap('❌ delete 需要 id');
+                const scope = decoded.scope === 'global' ? 'global' : 'project';
+                const ok = await client().deleteWorkflow(decoded.id, scope);
+                return wrap(ok ? `✅ 已删除 ${scope}/${decoded.id}` : `未找到 ${scope}/${decoded.id}`);
+            }
+            default:
+                return wrap(`❌ 未知 action: ${String(decoded.action)}`);
+        }
+    }));
+}

package/dist/utils.d.ts

@@ -1,12 +1,6 @@
 /**
  * MCP Server 工具函数
  */
-export type RuleType = string;
-export declare const RULE_TYPE_LABELS: Record<string, string>;
-/**
- * 获取指定类型的规则 (动态: 从 meta 获取标签)
- */
-export declare function getRules(projectId: string, ruleType?: string): Promise<string>;
 /**
  * 解码 Unicode 转义序列
  * 将 \uXXXX 格式的转义序列转换为实际字符

package/dist/utils.js

@@ -1,50 +1,6 @@
 /**
  * MCP Server 工具函数
  */
-import { getClient } from './storage/httpClient.js';
-// 默认规则类型标签 (fallback)
-const DEFAULT_LABELS = {
-    userStyles: '用户沟通规则',
-    codeStyle: '编码风格规则',
-    reviewRules: '代码审查规则',
-    testRules: '错误分析规则',
-    unitTests: '代码测试规则',
-};
-// 兼容导出
-export const RULE_TYPE_LABELS = DEFAULT_LABELS;
-/**
- * 将字符串数组格式化为 Markdown 列表
- */
-function formatRulesList(rules) {
-    if (!rules || rules.length === 0)
-        return '';
-    return rules.map((s, i) => `${i + 1}. ${s}`).join('\n\n');
-}
-/**
- * 获取指定类型的规则 (动态: 从 meta 获取标签)
- */
-export async function getRules(projectId, ruleType) {
-    const client = getClient();
-    const meta = await client.getRulesMeta();
-    if (ruleType) {
-        const rules = await client.getRulesApi(ruleType);
-        if (!rules || rules.length === 0)
-            return '';
-        const label = meta[ruleType]?.label || DEFAULT_LABELS[ruleType] || ruleType;
-        return `[${label}]\n${formatRulesList(rules)}`;
-    }
-    // 返回所有规则 (从 meta 获取所有类型)
-    const types = Object.keys(meta).length > 0 ? Object.keys(meta) : Object.keys(DEFAULT_LABELS);
-    const allRules = [];
-    for (const type of types) {
-        const rules = await client.getRulesApi(type);
-        if (rules && rules.length > 0) {
-            const label = meta[type]?.label || DEFAULT_LABELS[type] || type;
-            allRules.push(`[${label}]\n${formatRulesList(rules)}`);
-        }
-    }
-    return allRules.join('\n\n---\n\n');
-}
 /**
  * 解码 Unicode 转义序列
  * 将 \uXXXX 格式的转义序列转换为实际字符

package/package.json

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

package/templates/AGENT.md

@@ -12,9 +12,10 @@ kg_discuss(action:"list") -> ???????
 ## 1. ????????
 
 - ??: `kg_flowchart(action:"list|get|get_node|update_node|delete_node|batch_add|bind|unbind|orphans|health|create_chart|delete_chart")`
-- ??: `kg_rules(action:"get|save|get_meta|save_meta")`
+- ??: `kg_workflow()` / `kg_workflow(id:"...")` / `kg_workflow(action:"save|delete")`
 - ??: `kg_task(action:"create|get|update|archive|delete")`
 - ??: `kg_files(action:"list|read|upload|download|public_*")`
+- ??: `kg_ref(action:"list|get|save|delete|read_file")`
 - ??/??: `kg_discuss(...)`, `kg_meeting(...)`
 - ????: `code_scan()`, `code_smart_context(symbolName)`, `code_full_path(symbolA, symbolB)`
 - ????: ?????????????????????????????? fallback????????????
@@ -22,7 +23,7 @@ kg_discuss(action:"list") -> ???????
 ## 2. ?????
 
 ### Step 1: ????
-1. ?? `kg_flowchart(get)` ????????? `kg_rules(get)` ?????
+1. ?? `kg_flowchart(get)` ????????? `kg_workflow()` ?????
 2. ???????? `kg_flowchart(get_node, expand:2, includeDoc:true, includeFiles:true)`?
 3. ????? `subFlowchart`???????????????
 4. ??????????? `code_scan()`??? `code_smart_context` / `code_full_path`?