@ppdocs/mcp 2.6.16 → 2.6.18

package/dist/storage/httpClient.d.ts

@@ -22,6 +22,9 @@ export declare class PpdocsApiClient {
         title?: string;
         description?: string;
         userStyles?: string[];
+        testRules?: string[];
+        reviewRules?: string[];
+        codeStyle?: string[];
     }): Promise<NodeData | null>;
     deleteNode(nodeId: string): Promise<boolean>;
     lockNode(nodeId: string, locked: boolean): Promise<NodeData | null>;
@@ -59,6 +62,9 @@ export declare function updateRoot(_projectId: string, updates: {
     title?: string;
     description?: string;
     userStyles?: string[];
+    testRules?: string[];
+    reviewRules?: string[];
+    codeStyle?: string[];
 }): Promise<NodeData | null>;
 export declare function deleteNode(_projectId: string, nodeId: string): Promise<boolean>;
 export declare function lockNode(_projectId: string, nodeId: string, locked: boolean): Promise<NodeData | null>;

package/dist/storage/httpClient.js

@@ -192,7 +192,7 @@ export class PpdocsApiClient {
         }
     }
     async updateRoot(updates) {
-        // 专用根节点更新，支持 userStyles
+        // 专用根节点更新，支持所有规则字段
         const root = await this.getNode('root');
         if (!root)
             return null;
@@ -206,6 +206,12 @@ export class PpdocsApiClient {
             payload.description = updates.description;
         if (updates.userStyles !== undefined)
             payload.userStyles = updates.userStyles;
+        if (updates.testRules !== undefined)
+            payload.testRules = updates.testRules;
+        if (updates.reviewRules !== undefined)
+            payload.reviewRules = updates.reviewRules;
+        if (updates.codeStyle !== undefined)
+            payload.codeStyle = updates.codeStyle;
         try {
             return await this.request('/nodes/root', {
                 method: 'PUT',

package/dist/storage/types.d.ts

@@ -40,12 +40,16 @@ export interface NodeData {
     isOrigin?: boolean;
     signature: string;
     categories: string[];
+    path: string;
     description: string;
     dataInput?: DataRef;
     dataOutput?: DataRef;
     dependencies: Dependency[];
     relatedFiles?: string[];
     userStyles?: string[];
+    testRules?: string[];
+    reviewRules?: string[];
+    codeStyle?: string[];
     createdAt?: string;
     updatedAt?: string;
     lastAccessedAt?: string;

package/dist/tools/index.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import * as storage from '../storage/httpClient.js';
-import { decodeUnicodeEscapes, decodeObjectStrings, wrapResult, clearStyleCache, getRootStyle } from '../utils.js';
+import { decodeUnicodeEscapes, decodeObjectStrings, wrapResult, clearStyleCache, getRules, RULE_TYPE_LABELS } from '../utils.js';
 // 辅助函数: 包装返回结果
 async function wrap(projectId, text) {
     const wrapped = await wrapResult(projectId, text);
@@ -12,8 +12,9 @@ export function registerTools(server, projectId, _user) {
         title: z.string().describe('节点标题'),
         type: z.enum(['logic', 'data', 'intro']).describe('节点类型'),
         description: z.string().describe('Markdown描述(用Mermaid流程图+表格,禁止纯文字)'),
+        path: z.string().min(1).describe('目录路径(必填,如"/前端/组件")'),
+        tags: z.array(z.string()).min(3).describe('分类标签(至少3个)'),
         signature: z.string().optional().describe('唯一签名(用于依赖匹配,默认=title)'),
-        tags: z.array(z.string()).optional().describe('分类标签'),
         dependencies: z.array(z.object({
             name: z.string().describe('目标节点的signature'),
             description: z.string().describe('依赖说明')
@@ -28,7 +29,8 @@ export function registerTools(server, projectId, _user) {
             // x, y 不传递，由 httpClient 智能计算位置
             locked: false,
             signature: args.signature || args.title,
-            categories: args.tags || [],
+            categories: args.tags,
+            path: args.path,
             dependencies: args.dependencies || [],
             relatedFiles: args.relatedFiles || []
         });
@@ -45,8 +47,11 @@ export function registerTools(server, projectId, _user) {
         title: z.string().optional().describe('新标题'),
         signature: z.string().optional().describe('新签名'),
         description: z.string().optional().describe('新描述(Markdown)'),
+        path: z.string().optional().describe('目录路径(如"/前端/组件")'),
+        x: z.number().optional().describe('X坐标'),
+        y: z.number().optional().describe('Y坐标'),
         status: z.enum(['incomplete', 'complete', 'fixing', 'refactoring', 'deprecated']).optional().describe('状态'),
-        tags: z.array(z.string()).optional().describe('分类标签'),
+        tags: z.array(z.string()).min(3).optional().describe('分类标签(至少3个)'),
         dependencies: z.array(z.object({
             name: z.string(),
             description: z.string()
@@ -65,7 +70,7 @@ export function registerTools(server, projectId, _user) {
             impact: z.string().optional()
         })).optional().describe('修复记录')
     }, async (args) => {
-        const { nodeId, tags, relatedFiles, versions, bugfixes, ...rest } = args;
+        const { nodeId, tags, relatedFiles, versions, bugfixes, path, ...rest } = args;
         // 根节点必须使用 kg_update_root 更新
         if (nodeId === 'root') {
             return wrap(projectId, '❌ 根节点请使用 kg_update_root 方法更新');
@@ -80,35 +85,50 @@ export function registerTools(server, projectId, _user) {
             updates.versions = versions;
         if (bugfixes !== undefined)
             updates.bugfixes = bugfixes;
+        if (path !== undefined)
+            updates.path = path;
         const node = await storage.updateNode(projectId, nodeId, updates);
         return wrap(projectId, node ? JSON.stringify(node, null, 2) : '更新失败(节点不存在或已锁定)');
     });
-    // 3.5 更新根节点 (专用方法，支持 userStyles)
+    // 3.5 更新根节点 (专用方法，支持所有规则)
     server.tool('kg_update_root', '更新根节点(项目规则，锁定时不可更新)', {
         title: z.string().optional().describe('项目标题'),
         description: z.string().optional().describe('项目描述(Markdown)'),
-        userStyles: z.array(z.string()).optional().describe('项目规则列表(字符串数组，每条一个规则)')
+        userStyles: z.array(z.string()).optional().describe('项目规则(字符串数组)'),
+        testRules: z.array(z.string()).optional().describe('测试规则(字符串数组)'),
+        reviewRules: z.array(z.string()).optional().describe('审查规则(字符串数组)'),
+        codeStyle: z.array(z.string()).optional().describe('编码风格(字符串数组)')
     }, async (args) => {
         // 空参数检查
-        if (args.title === undefined && args.description === undefined && args.userStyles === undefined) {
-            return wrap(projectId, '❌ 请至少提供一个更新参数(title/description/userStyles)');
+        const hasUpdate = args.title !== undefined || args.description !== undefined ||
+            args.userStyles !== undefined || args.testRules !== undefined ||
+            args.reviewRules !== undefined || args.codeStyle !== undefined;
+        if (!hasUpdate) {
+            return wrap(projectId, '❌ 请至少提供一个更新参数');
         }
         const node = await storage.updateRoot(projectId, {
             title: args.title,
             description: args.description,
-            userStyles: args.userStyles
+            userStyles: args.userStyles,
+            testRules: args.testRules,
+            reviewRules: args.reviewRules,
+            codeStyle: args.codeStyle
         });
         if (node)
             clearStyleCache();
         return wrap(projectId, node ? JSON.stringify(node, null, 2) : '更新失败(根节点已锁定)');
     });
     // 3.6 获取项目规则 (独立方法，按需调用)
-    server.tool('kg_get_rules', '获取项目规则列表(按需调用)', {}, async () => {
-        const style = await getRootStyle(projectId);
-        if (!style || style.trim() === '') {
-            return { content: [{ type: 'text', text: '暂无项目规则' }] };
+    server.tool('kg_get_rules', '获取项目规则(可指定类型或获取全部)', {
+        ruleType: z.enum(['userStyles', 'testRules', 'reviewRules', 'codeStyle']).optional()
+            .describe('规则类型: userStyles=项目规则, testRules=测试规则, reviewRules=审查规则, codeStyle=编码风格。不传则返回全部')
+    }, async (args) => {
+        const rules = await getRules(projectId, args.ruleType);
+        if (!rules || rules.trim() === '') {
+            const typeName = args.ruleType ? RULE_TYPE_LABELS[args.ruleType] : '项目';
+            return { content: [{ type: 'text', text: `暂无${typeName}规则` }] };
         }
-        return { content: [{ type: 'text', text: `[项目规则]\n${style}` }] };
+        return { content: [{ type: 'text', text: rules }] };
     });
     // 4. 锁定节点 (只能锁定，解锁需用户在前端手动操作)
     server.tool('kg_lock_node', '锁定节点(锁定后只能读取，解锁需用户在前端手动操作)', {
@@ -252,8 +272,80 @@ export function registerTools(server, projectId, _user) {
         }
         return wrap(projectId, lines.join('\n'));
     });
+    // 10. 获取知识库树状图
+    server.tool('kg_get_tree', '获取知识库的目录树结构(按 path 分组)', {}, async () => {
+        const nodes = await storage.listNodes(projectId);
+        const root = { name: '/', type: 'folder', children: [] };
+        // 过滤掉根节点
+        const docNodes = nodes.filter(n => !n.isOrigin && n.id !== 'root');
+        for (const node of docNodes) {
+            const pathSegments = (node.path || '').split('/').filter(Boolean);
+            let current = root;
+            // 遍历路径段，创建目录结构
+            for (const segment of pathSegments) {
+                if (!current.children)
+                    current.children = [];
+                let child = current.children.find(c => c.name === segment && c.type === 'folder');
+                if (!child) {
+                    child = { name: segment, type: 'folder', children: [] };
+                    current.children.push(child);
+                }
+                current = child;
+            }
+            // 添加节点
+            if (!current.children)
+                current.children = [];
+            current.children.push({
+                name: node.title,
+                type: 'node',
+                nodeId: node.id,
+                status: node.status
+            });
+        }
+        // 递归排序 (目录在前，节点在后)
+        function sortTree(node) {
+            if (!node.children)
+                return;
+            node.children.sort((a, b) => {
+                if (a.type === 'folder' && b.type !== 'folder')
+                    return -1;
+                if (a.type !== 'folder' && b.type === 'folder')
+                    return 1;
+                return a.name.localeCompare(b.name, 'zh-CN');
+            });
+            for (const child of node.children) {
+                if (child.type === 'folder')
+                    sortTree(child);
+            }
+        }
+        sortTree(root);
+        // 格式化为文本树
+        function formatTree(node, prefix = '', isLast = true) {
+            const lines = [];
+            const connector = isLast ? '└── ' : '├── ';
+            const childPrefix = isLast ? '    ' : '│   ';
+            if (node.name !== '/') {
+                const icon = node.type === 'folder' ? '📁' : '📄';
+                const status = node.status ? ` [${node.status}]` : '';
+                lines.push(`${prefix}${connector}${icon} ${node.name}${status}`);
+            }
+            if (node.children) {
+                const children = node.children;
+                for (let i = 0; i < children.length; i++) {
+                    const child = children[i];
+                    const childIsLast = i === children.length - 1;
+                    const newPrefix = node.name === '/' ? '' : prefix + childPrefix;
+                    lines.push(...formatTree(child, newPrefix, childIsLast));
+                }
+            }
+            return lines;
+        }
+        const treeText = formatTree(root).join('\n');
+        const summary = `共 ${docNodes.length} 个节点\n\n${treeText}`;
+        return wrap(projectId, summary);
+    });
     // ===================== 任务管理工具 =====================
-    // 10. 创建任务
+    // 11. 创建任务
     server.tool('task_create', '创建开发任务,记录目标和关联节点', {
         title: z.string().describe('任务标题'),
         description: z.string().describe('任务描述(Markdown)'),

package/dist/utils.d.ts

@@ -1,12 +1,18 @@
 /**
  * MCP Server 工具函数
  */
+export type RuleType = 'userStyles' | 'testRules' | 'reviewRules' | 'codeStyle';
+export declare const RULE_TYPE_LABELS: Record<RuleType, string>;
 /**
- * 获取根节点的用户风格
+ * 获取指定类型的规则
+ */
+export declare function getRules(projectId: string, ruleType?: RuleType): Promise<string>;
+/**
+ * 获取根节点的用户风格 (兼容旧接口)
  */
 export declare function getRootStyle(projectId: string): Promise<string>;
 /**
- * 清除风格缓存 (当根节点更新时调用)
+ * 清除规则缓存 (当根节点更新时调用)
  */
 export declare function clearStyleCache(): void;
 /**

package/dist/utils.js

@@ -2,51 +2,76 @@
  * MCP Server 工具函数
  */
 import * as storage from './storage/httpClient.js';
-// 缓存根节点风格 (避免每次调用都请求)
-let cachedRootStyle = null;
+// 规则类型显示名
+export const RULE_TYPE_LABELS = {
+    userStyles: '项目规则',
+    testRules: '测试规则',
+    reviewRules: '审查规则',
+    codeStyle: '编码风格',
+};
+// 缓存根节点 (避免每次调用都请求)
+let cachedRootNode = null;
 let cacheProjectId = null;
 /**
- * 将 userStyles 字符串数组格式化为 Markdown 列表
+ * 将字符串数组格式化为 Markdown 列表
  */
-function formatUserStyles(styles) {
-    if (!styles || styles.length === 0)
+function formatRulesList(rules) {
+    if (!rules || rules.length === 0)
         return '';
-    return styles.map((s, i) => `${i + 1}. ${s}`).join('\n\n');
+    return rules.map((s, i) => `${i + 1}. ${s}`).join('\n\n');
 }
 /**
- * 获取根节点的用户风格
+ * 获取根节点数据 (带缓存)
  */
-export async function getRootStyle(projectId) {
-    // 缓存命中
-    if (cachedRootStyle !== null && cacheProjectId === projectId) {
-        return cachedRootStyle;
+async function getCachedRoot(projectId) {
+    if (cachedRootNode !== null && cacheProjectId === projectId) {
+        return cachedRootNode;
     }
     try {
         const rootNode = await storage.getNode(projectId, 'root');
-        if (!rootNode) {
-            cachedRootStyle = '';
-            cacheProjectId = projectId;
-            return '';
-        }
-        // 使用 userStyles 字符串数组
-        if (rootNode.userStyles && rootNode.userStyles.length > 0) {
-            cachedRootStyle = formatUserStyles(rootNode.userStyles);
-        }
-        else {
-            cachedRootStyle = '';
-        }
+        cachedRootNode = rootNode;
         cacheProjectId = projectId;
-        return cachedRootStyle;
+        return cachedRootNode;
     }
     catch {
+        return null;
+    }
+}
+/**
+ * 获取指定类型的规则
+ */
+export async function getRules(projectId, ruleType) {
+    const rootNode = await getCachedRoot(projectId);
+    if (!rootNode)
         return '';
+    // 如果指定了类型，只返回该类型
+    if (ruleType) {
+        const rules = rootNode[ruleType];
+        if (!rules || rules.length === 0)
+            return '';
+        return `[${RULE_TYPE_LABELS[ruleType]}]\n${formatRulesList(rules)}`;
+    }
+    // 返回所有规则
+    const allRules = [];
+    for (const type of Object.keys(RULE_TYPE_LABELS)) {
+        const rules = rootNode[type];
+        if (rules && rules.length > 0) {
+            allRules.push(`[${RULE_TYPE_LABELS[type]}]\n${formatRulesList(rules)}`);
+        }
     }
+    return allRules.join('\n\n---\n\n');
+}
+/**
+ * 获取根节点的用户风格 (兼容旧接口)
+ */
+export async function getRootStyle(projectId) {
+    return getRules(projectId, 'userStyles');
 }
 /**
- * 清除风格缓存 (当根节点更新时调用)
+ * 清除规则缓存 (当根节点更新时调用)
  */
 export function clearStyleCache() {
-    cachedRootStyle = null;
+    cachedRootNode = null;
     cacheProjectId = null;
 }
 /**

package/package.json

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