@ppdocs/mcp 3.0.0 → 3.0.2

package/dist/storage/httpClient.d.ts

@@ -4,7 +4,7 @@
  *
  * API URL 格式: http://localhost:20001/api/:projectId/:password/...
  */
-import type { DocData, DocNode, DocSearchResult, Task, TaskSummary, TaskLogType, TaskExperience, FileInfo } from './types.js';
+import type { DocData, DocNode, DocSearchResult, Task, TaskSummary, TaskLogType, TaskExperience, FileInfo, RuleMeta } from './types.js';
 interface TreeNode {
     path: string;
     name: string;
@@ -14,6 +14,7 @@ interface TreeNode {
 }
 export declare class PpdocsApiClient {
     private baseUrl;
+    private serverUrl;
     constructor(apiUrl: string);
     private request;
     listDocs(): Promise<DocNode[]>;
@@ -28,6 +29,11 @@ export declare class PpdocsApiClient {
     getTree(): Promise<TreeNode[]>;
     getRulesApi(ruleType: string): Promise<string[]>;
     saveRulesApi(ruleType: string, rules: string[]): Promise<boolean>;
+    getRulesMeta(): Promise<Record<string, RuleMeta>>;
+    saveRulesMeta(meta: Record<string, RuleMeta>): Promise<boolean>;
+    crossGetRulesMeta(target: string): Promise<Record<string, RuleMeta>>;
+    getGlobalRulesMeta(): Promise<Record<string, RuleMeta>>;
+    saveGlobalRulesMeta(meta: Record<string, RuleMeta>): Promise<boolean>;
     listTasks(status?: 'active' | 'archived'): Promise<TaskSummary[]>;
     getTask(taskId: string): Promise<Task | null>;
     createTask(task: {
@@ -37,6 +43,14 @@ export declare class PpdocsApiClient {
     }, creator: string): Promise<Task>;
     addTaskLog(taskId: string, logType: TaskLogType, content: string): Promise<Task | null>;
     completeTask(taskId: string, experience: TaskExperience): Promise<Task | null>;
+    /** 创建项目 (公开路由，无需认证) */
+    createProject(id: string, name: string, description?: string, projectPath?: string): Promise<{
+        project: {
+            id: string;
+            name: string;
+        };
+        password: string;
+    }>;
     /** 列出所有可访问的项目 */
     crossListProjects(): Promise<{
         id: string;
@@ -90,6 +104,11 @@ export declare function getDocsByStatus(_projectId: string, statusList: string[]
 export declare function getTree(_projectId: string): Promise<TreeNode[]>;
 export declare function getRules(_projectId: string, ruleType: string): Promise<string[]>;
 export declare function saveRules(_projectId: string, ruleType: string, rules: string[]): Promise<boolean>;
+export declare function getRulesMeta(): Promise<Record<string, RuleMeta>>;
+export declare function saveRulesMeta(meta: Record<string, RuleMeta>): Promise<boolean>;
+export declare function crossGetRulesMeta(target: string): Promise<Record<string, RuleMeta>>;
+export declare function getGlobalRulesMeta(): Promise<Record<string, RuleMeta>>;
+export declare function saveGlobalRulesMeta(meta: Record<string, RuleMeta>): Promise<boolean>;
 export declare function listTasks(_projectId: string, status?: 'active' | 'archived'): Promise<TaskSummary[]>;
 export declare function getTask(_projectId: string, taskId: string): Promise<Task | null>;
 export declare function createTask(_projectId: string, task: {
@@ -99,6 +118,13 @@ export declare function createTask(_projectId: string, task: {
 }, creator: string): Promise<Task>;
 export declare function addTaskLog(_projectId: string, taskId: string, logType: TaskLogType, content: string): Promise<Task | null>;
 export declare function completeTask(_projectId: string, taskId: string, experience: TaskExperience): Promise<Task | null>;
+export declare function createProject(id: string, name: string, description?: string, projectPath?: string): Promise<{
+    project: {
+        id: string;
+        name: string;
+    };
+    password: string;
+}>;
 export declare function crossListProjects(): Promise<{
     id: string;
     name: string;

package/dist/storage/httpClient.js

@@ -91,9 +91,12 @@ function buildTree(docs) {
 // API 客户端类
 export class PpdocsApiClient {
     baseUrl; // http://localhost:20001/api/projectId/password
+    serverUrl; // http://localhost:20001
     constructor(apiUrl) {
-        // 移除末尾斜杠
         this.baseUrl = apiUrl.replace(/\/$/, '');
+        // 从 /api/projectId/password 提取服务器根地址
+        const apiIndex = this.baseUrl.indexOf('/api/');
+        this.serverUrl = apiIndex > 0 ? this.baseUrl.substring(0, apiIndex) : this.baseUrl;
     }
     // ============ HTTP 请求工具 ============
     async request(path, options = {}) {
@@ -227,6 +230,54 @@ export class PpdocsApiClient {
             return false;
         }
     }
+    async getRulesMeta() {
+        try {
+            return await this.request('/rules-meta');
+        }
+        catch {
+            return {};
+        }
+    }
+    async saveRulesMeta(meta) {
+        try {
+            await this.request('/rules-meta', {
+                method: 'PUT',
+                body: JSON.stringify(meta)
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async crossGetRulesMeta(target) {
+        try {
+            return await this.request(`/cross/${encodeURIComponent(target)}/rules-meta`);
+        }
+        catch {
+            return {};
+        }
+    }
+    async getGlobalRulesMeta() {
+        try {
+            return await this.request('/global-rules-meta');
+        }
+        catch {
+            return {};
+        }
+    }
+    async saveGlobalRulesMeta(meta) {
+        try {
+            await this.request('/global-rules-meta', {
+                method: 'PUT',
+                body: JSON.stringify(meta)
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     // ============ 任务管理 ============
     async listTasks(status) {
         const query = status ? `?status=${status}` : '';
@@ -277,6 +328,22 @@ export class PpdocsApiClient {
             return null;
         }
     }
+    // ============ 项目管理 ============
+    /** 创建项目 (公开路由，无需认证) */
+    async createProject(id, name, description, projectPath) {
+        const url = `${this.serverUrl}/api/projects`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ id, name, description: description || '', project_path: projectPath || '' }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        const json = await response.json();
+        return json.data;
+    }
     // ============ 跨项目只读访问 ============
     /** 列出所有可访问的项目 */
     async crossListProjects() {
@@ -441,6 +508,21 @@ export async function getRules(_projectId, ruleType) {
 export async function saveRules(_projectId, ruleType, rules) {
     return getClient().saveRulesApi(ruleType, rules);
 }
+export async function getRulesMeta() {
+    return getClient().getRulesMeta();
+}
+export async function saveRulesMeta(meta) {
+    return getClient().saveRulesMeta(meta);
+}
+export async function crossGetRulesMeta(target) {
+    return getClient().crossGetRulesMeta(target);
+}
+export async function getGlobalRulesMeta() {
+    return getClient().getGlobalRulesMeta();
+}
+export async function saveGlobalRulesMeta(meta) {
+    return getClient().saveGlobalRulesMeta(meta);
+}
 // ============ 任务管理 ============
 export async function listTasks(_projectId, status) {
     return getClient().listTasks(status);
@@ -457,6 +539,10 @@ export async function addTaskLog(_projectId, taskId, logType, content) {
 export async function completeTask(_projectId, taskId, experience) {
     return getClient().completeTask(taskId, experience);
 }
+// ============ 项目管理 ============
+export async function createProject(id, name, description, projectPath) {
+    return getClient().createProject(id, name, description, projectPath);
+}
 // ============ 跨项目只读访问 ============
 export async function crossListProjects() {
     return getClient().crossListProjects();

package/dist/storage/types.d.ts

@@ -47,6 +47,12 @@ export interface Project {
     createdAt?: string;
     projectPath?: string;
 }
+export interface RuleMeta {
+    label: string;
+    keywords: string[];
+    min_hits: number;
+    always?: boolean;
+}
 export interface FileInfo {
     name: string;
     path: string;

package/dist/tools/index.js

@@ -21,6 +21,21 @@ export function registerTools(server, projectId, _user) {
             return wrap(`获取项目列表失败: ${String(e)}`);
         }
     });
+    // 0.1 创建项目
+    server.tool('kg_create_project', '创建新项目。返回项目ID和密码(密码用于MCP连接)', {
+        id: z.string().describe('项目ID(英文/数字/中文，如"my-app")'),
+        name: z.string().describe('项目名称'),
+        description: z.string().optional().describe('项目简介'),
+        projectPath: z.string().optional().describe('项目源码路径(本地绝对路径)'),
+    }, async (args) => {
+        try {
+            const result = await storage.createProject(args.id, args.name, args.description, args.projectPath || process.cwd());
+            return wrap(`✅ 项目创建成功\n\n- 项目ID: ${result.project.id}\n- 项目名: ${result.project.name}\n- 密码: ${result.password}\n\nMCP 连接地址: http://<服务器IP>:20001/api/${result.project.id}/${result.password}`);
+        }
+        catch (e) {
+            return wrap(`❌ ${String(e)}`);
+        }
+    });
     // ===================== 文档管理 =====================
     // 1. 创建文档
     server.tool('kg_create_node', '创建知识文档。使用目录路径分类，文件名作为文档名', {
@@ -183,25 +198,29 @@ export function registerTools(server, projectId, _user) {
     });
     // 3.6 获取项目规则
     server.tool('kg_get_rules', '获取项目规则(可指定类型或获取全部)。支持跨项目只读访问', {
-        ruleType: z.enum(['userStyles', 'testRules', 'reviewRules', 'codeStyle', 'unitTests']).optional()
-            .describe('规则类型: userStyles=用户沟通规则, codeStyle=编码风格规则, reviewRules=代码审查规则, testRules=错误分析规则, unitTests=代码测试规则。不传则返回全部'),
+        ruleType: z.string().optional()
+            .describe('规则类型(如 userStyles, codeStyle, reviewRules, testRules, unitTests, 或自定义类型)。不传则返回全部'),
         targetProject: z.string().optional().describe('目标项目ID或名称(不填=当前项目，跨项目只读)')
     }, async (args) => {
         // 跨项目访问
         if (args.targetProject) {
+            const crossMeta = await storage.crossGetRulesMeta(args.targetProject);
             if (args.ruleType) {
                 const rules = await storage.crossGetRules(args.targetProject, args.ruleType);
                 if (rules.length === 0) {
-                    return { content: [{ type: 'text', text: `暂无${RULE_TYPE_LABELS[args.ruleType]}规则(项目: ${args.targetProject})` }] };
+                    const label = crossMeta[args.ruleType]?.label || args.ruleType;
+                    return { content: [{ type: 'text', text: `暂无${label}规则(项目: ${args.targetProject})` }] };
                 }
                 return { content: [{ type: 'text', text: `[跨项目: ${args.targetProject}]\n\n${rules.join('\n')}` }] };
             }
-            // 获取全部规则
+            // 获取全部规则 (从 meta 获取所有类型)
+            const types = Object.keys(crossMeta).length > 0 ? Object.keys(crossMeta) : Object.keys(RULE_TYPE_LABELS);
             const allRules = [];
-            for (const type of ['userStyles', 'codeStyle', 'reviewRules', 'testRules', 'unitTests']) {
+            for (const type of types) {
                 const rules = await storage.crossGetRules(args.targetProject, type);
                 if (rules.length > 0) {
-                    allRules.push(`## ${RULE_TYPE_LABELS[type]}\n${rules.join('\n')}`);
+                    const label = crossMeta[type]?.label || RULE_TYPE_LABELS[type] || type;
+                    allRules.push(`## ${label}\n${rules.join('\n')}`);
                 }
             }
             if (allRules.length === 0) {
@@ -210,17 +229,18 @@ export function registerTools(server, projectId, _user) {
             return { content: [{ type: 'text', text: `[跨项目: ${args.targetProject}]\n\n${allRules.join('\n\n')}` }] };
         }
         // 当前项目
-        const rules = await getRules(projectId, args.ruleType);
+        const rules = await getRules(projectId, args.ruleType || undefined);
         if (!rules || rules.trim() === '') {
-            const typeName = args.ruleType ? RULE_TYPE_LABELS[args.ruleType] : '项目';
+            const meta = await storage.getRulesMeta();
+            const typeName = args.ruleType ? (meta[args.ruleType]?.label || args.ruleType) : '项目';
             return { content: [{ type: 'text', text: `暂无${typeName}规则` }] };
         }
         return { content: [{ type: 'text', text: rules }] };
     });
     // 3.7 保存项目规则
     server.tool('kg_save_rules', '保存单个类型的项目规则(独立文件存储)', {
-        ruleType: z.enum(['userStyles', 'testRules', 'reviewRules', 'codeStyle', 'unitTests'])
-            .describe('规则类型: userStyles=用户沟通规则, codeStyle=编码风格规则, reviewRules=代码审查规则, testRules=错误分析规则, unitTests=代码测试规则'),
+        ruleType: z.string()
+            .describe('规则类型(如 userStyles, codeStyle, reviewRules, testRules, unitTests, 或自定义类型)'),
         rules: z.array(z.string()).describe('规则数组')
     }, async (args) => {
         const decoded = decodeObjectStrings(args);
@@ -228,7 +248,87 @@ export function registerTools(server, projectId, _user) {
         if (!success) {
             return wrap('❌ 保存失败');
         }
-        return wrap(`✅ ${RULE_TYPE_LABELS[decoded.ruleType]}已保存 (${decoded.rules.length} 条)`);
+        const meta = await storage.getRulesMeta();
+        const label = meta[decoded.ruleType]?.label || decoded.ruleType;
+        return wrap(`✅ ${label}已保存 (${decoded.rules.length} 条)`);
+    });
+    // 3.8 获取规则触发配置
+    server.tool('kg_get_rules_meta', '获取规则触发配置(所有类型的标签、关键词、触发数)。用于查看/编辑 hooks 触发条件', {}, async () => {
+        try {
+            const meta = await storage.getRulesMeta();
+            if (Object.keys(meta).length === 0) {
+                return wrap('暂无规则配置');
+            }
+            const lines = Object.entries(meta).map(([type, m]) => {
+                const kw = m.keywords.length > 0 ? m.keywords.join(', ') : '(无)';
+                const trigger = m.always ? '始终触发' : `关键词≥${m.min_hits}: ${kw}`;
+                return `- **${m.label}** (${type}): ${trigger}`;
+            });
+            return wrap(`规则触发配置:\n\n${lines.join('\n')}`);
+        }
+        catch (e) {
+            return wrap(`❌ ${String(e)}`);
+        }
+    });
+    // 3.9 保存规则触发配置
+    server.tool('kg_save_rules_meta', '保存规则触发配置(标签、关键词、触发数)。支持新增自定义规则类型', {
+        meta: z.record(z.string(), z.object({
+            label: z.string().describe('规则显示名称'),
+            keywords: z.array(z.string()).default([]).describe('触发关键词列表'),
+            min_hits: z.number().default(1).describe('最低触发关键词数'),
+            always: z.boolean().default(false).describe('是否始终触发(如 userStyles)')
+        })).describe('规则类型 → 触发配置的映射')
+    }, async (args) => {
+        try {
+            const decoded = decodeObjectStrings(args.meta);
+            const success = await storage.saveRulesMeta(decoded);
+            if (!success) {
+                return wrap('❌ 保存失败');
+            }
+            return wrap(`✅ 规则触发配置已保存 (${Object.keys(decoded).length} 个类型)`);
+        }
+        catch (e) {
+            return wrap(`❌ ${String(e)}`);
+        }
+    });
+    // 3.10 获取全局默认规则触发配置
+    server.tool('kg_get_global_rules_meta', '获取全局默认规则触发配置(新项目创建时继承此配置)', {}, async () => {
+        try {
+            const meta = await storage.getGlobalRulesMeta();
+            if (Object.keys(meta).length === 0) {
+                return wrap('暂无全局默认规则配置');
+            }
+            const lines = Object.entries(meta).map(([type, m]) => {
+                const kw = m.keywords.length > 0 ? m.keywords.join(', ') : '(无)';
+                const trigger = m.always ? '始终触发' : `关键词≥${m.min_hits}: ${kw}`;
+                return `- **${m.label}** (${type}): ${trigger}`;
+            });
+            return wrap(`全局默认规则触发配置:\n\n${lines.join('\n')}`);
+        }
+        catch (e) {
+            return wrap(`❌ ${String(e)}`);
+        }
+    });
+    // 3.11 保存全局默认规则触发配置
+    server.tool('kg_save_global_rules_meta', '保存全局默认规则触发配置(新项目创建时继承此配置)。支持新增自定义规则类型', {
+        meta: z.record(z.string(), z.object({
+            label: z.string().describe('规则显示名称'),
+            keywords: z.array(z.string()).default([]).describe('触发关键词列表'),
+            min_hits: z.number().default(1).describe('最低触发关键词数'),
+            always: z.boolean().default(false).describe('是否始终触发(如 userStyles)')
+        })).describe('规则类型 → 触发配置的映射')
+    }, async (args) => {
+        try {
+            const decoded = decodeObjectStrings(args.meta);
+            const success = await storage.saveGlobalRulesMeta(decoded);
+            if (!success) {
+                return wrap('❌ 保存失败');
+            }
+            return wrap(`✅ 全局默认规则触发配置已保存 (${Object.keys(decoded).length} 个类型)`);
+        }
+        catch (e) {
+            return wrap(`❌ ${String(e)}`);
+        }
     });
     // 5. 读取单个文档详情
     server.tool('kg_read_node', '读取文档完整内容(简介、正文、版本历史、修复记录)。支持跨项目只读访问', {

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -2,14 +2,16 @@
  * MCP Server 工具函数
  */
 import * as storage from './storage/httpClient.js';
-// 规则类型显示名
-export const RULE_TYPE_LABELS = {
+// 默认规则类型标签 (fallback)
+const DEFAULT_LABELS = {
     userStyles: '用户沟通规则',
     codeStyle: '编码风格规则',
     reviewRules: '代码审查规则',
     testRules: '错误分析规则',
     unitTests: '代码测试规则',
 };
+// 兼容导出
+export const RULE_TYPE_LABELS = DEFAULT_LABELS;
 /**
  * 将字符串数组格式化为 Markdown 列表
  */
@@ -19,22 +21,25 @@ function formatRulesList(rules) {
     return rules.map((s, i) => `${i + 1}. ${s}`).join('\n\n');
 }
 /**
- * 获取指定类型的规则 (从独立文件读取)
+ * 获取指定类型的规则 (动态: 从 meta 获取标签)
  */
 export async function getRules(projectId, ruleType) {
-    // 如果指定了类型，只返回该类型
+    const meta = await storage.getRulesMeta();
     if (ruleType) {
         const rules = await storage.getRules(projectId, ruleType);
         if (!rules || rules.length === 0)
             return '';
-        return `[${RULE_TYPE_LABELS[ruleType]}]\n${formatRulesList(rules)}`;
+        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 Object.keys(RULE_TYPE_LABELS)) {
+    for (const type of types) {
         const rules = await storage.getRules(projectId, type);
         if (rules && rules.length > 0) {
-            allRules.push(`[${RULE_TYPE_LABELS[type]}]\n${formatRulesList(rules)}`);
+            const label = meta[type]?.label || DEFAULT_LABELS[type] || type;
+            allRules.push(`[${label}]\n${formatRulesList(rules)}`);
         }
     }
     return allRules.join('\n\n---\n\n');

package/package.json

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

package/templates/hooks/hook.py

@@ -1,71 +1,46 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """
-Claude Code Hook - 关键词触发 + API 动态获取规则
+Claude Code Hook - 动态规则触发
+从服务器获取触发配置 (rules-meta) → 关键词匹配 → 叠加获取规则
+兼容 Python 2.7+ / 3.x，支持 Windows / macOS / Linux
 """
 
+from __future__ import print_function, unicode_literals
+
 import io
 import json
 import os
 import sys
-import urllib.request
 
-# Windows 编码修复
-sys.stdin = io.TextIOWrapper(sys.stdin.buffer, encoding="utf-8", errors="replace")
-sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
-sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
+# HTTP 库兼容
+try:
+    from urllib.request import Request, urlopen
+except ImportError:
+    from urllib2 import Request, urlopen
+
+# Windows 编码修复 (仅 Windows + Python 3 + 有 buffer 属性时)
+if sys.platform == "win32" and hasattr(sys.stdin, "buffer"):
+    try:
+        sys.stdin = io.TextIOWrapper(sys.stdin.buffer, encoding="utf-8", errors="replace")
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+        sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
+    except Exception:
+        pass
 
 
 # ╔══════════════════════════════════════════════════════════════╗
-# ║  配置区                                                       ║
+# ║  绕过词                                                       ║
 # ╚══════════════════════════════════════════════════════════════╝
 
-# 关键词规则 (触发关键词 → 请求对应规则类型)
-RULES = [
-    {
-        "keywords": ["bug","修复","错误","报错","失败","异常","严重","存在","还是","有"],
-        "min_hits": 2,
-        "rule_type": "testRules",  # 错误分析规则
-        "label": "错误分析规则",
-    },
-    {
-        "keywords": ["审查", "审核", "review", "检查"],
-        "min_hits": 1,
-        "rule_type": "reviewRules",  # 审查规则
-        "label": "代码审查规则",
-    },
-    {
-        "keywords": ["编码", "风格", "格式", "命名", "编写", "开始", "代码"],
-        "min_hits": 2,
-        "rule_type": "codeStyle",  # 编码风格
-        "label": "编码风格规则",
-    },
-    {
-        "keywords": ["开始", "进行", "准备", "测试", "单元", "用例", "test", "覆盖率"],
-        "min_hits": 2,
-        "rule_type": "unitTests",  # 代码测试
-        "label": "代码测试规则",
-    },
-]
-
-# 绕过词列表
 BYPASS = [
-    "补充",
-    "确定",
-    "确认",
-    "继续",
-    "好的",
-    "可以",
-    "ok",
-    "yes",
-    "hi",
-    "hello",
-    "你好",
+    "补充", "确定", "确认", "继续", "好的", "可以",
+    "ok", "yes", "hi", "hello", "你好",
 ]
 
 
 # ╔══════════════════════════════════════════════════════════════╗
-# ║  API 请求函数                                                  ║
+# ║  API 请求                                                      ║
 # ╚══════════════════════════════════════════════════════════════╝
 
 
@@ -75,25 +50,42 @@ def load_ppdocs_config():
     if not os.path.exists(config_path):
         return None
     try:
-        with open(config_path, "r", encoding="utf-8") as f:
+        with io.open(config_path, "r", encoding="utf-8") as f:
             return json.load(f)
-    except:
+    except Exception:
         return None
 
 
-def fetch_rules(api_base: str, project_id: str, key: str, rule_type: str) -> list:
-    """通过 HTTP API 获取指定类型的规则"""
-    url = f"{api_base}/api/{project_id}/{key}/rules/{rule_type}"
+def api_get(api_base, project_id, key, path):
+    """通用 GET 请求"""
+    url = "%s/api/%s/%s%s" % (api_base, project_id, key, path)
+    resp = None
     try:
-        req = urllib.request.Request(url, method="GET")
+        req = Request(url)
         req.add_header("Content-Type", "application/json")
-        with urllib.request.urlopen(req, timeout=3) as resp:
-            data = json.loads(resp.read().decode("utf-8"))
-            if data.get("success") and data.get("data"):
-                return data["data"]
-    except:
+        resp = urlopen(req, timeout=3)
+        data = json.loads(resp.read().decode("utf-8"))
+        if data.get("success") and data.get("data") is not None:
+            return data["data"]
+    except Exception:
         pass
-    return []
+    finally:
+        if resp is not None:
+            try:
+                resp.close()
+            except Exception:
+                pass
+    return None
+
+
+def fetch_rules_meta(api_base, project_id, key):
+    """获取规则触发配置"""
+    return api_get(api_base, project_id, key, "/rules-meta") or {}
+
+
+def fetch_rules(api_base, project_id, key, rule_type):
+    """获取指定类型的规则内容"""
+    return api_get(api_base, project_id, key, "/rules/" + rule_type) or []
 
 
 # ╔══════════════════════════════════════════════════════════════╗
@@ -101,27 +93,32 @@ def fetch_rules(api_base: str, project_id: str, key: str, rule_type: str) -> lis
 # ╚══════════════════════════════════════════════════════════════╝
 
 
-def count_hits(text: str, keywords: list) -> int:
+def count_hits(text, keywords):
     """计算关键词命中数量"""
     return sum(1 for kw in keywords if kw.lower() in text)
 
 
-def match_rule(text: str):
-    """匹配规则，返回 (rule, matched)"""
-    for rule in RULES:
-        hits = count_hits(text, rule["keywords"])
-        if hits >= rule.get("min_hits", 1):
-            return rule, True
-    return None, False
+def match_all(text, meta):
+    """匹配所有触发的规则类型，返回 [(rule_type, label), ...]"""
+    matched = []
+    for rule_type, config in meta.items():
+        if config.get("always"):
+            matched.append((rule_type, config.get("label", rule_type)))
+            continue
+        keywords = config.get("keywords", [])
+        min_hits = config.get("min_hits", 1)
+        if keywords and count_hits(text, keywords) >= min_hits:
+            matched.append((rule_type, config.get("label", rule_type)))
+    return matched
 
 
-def format_rules(items: list, label: str) -> str:
+def format_rules(items, label):
     """格式化规则输出"""
     if not items:
         return ""
-    lines = [f"# {label}\n"]
+    lines = ["# %s\n" % label]
     for item in items:
-        lines.append(f"- {item}")
+        lines.append("- %s" % item)
     return "\n".join(lines)
 
 
@@ -132,8 +129,9 @@ def format_rules(items: list, label: str) -> str:
 
 def main():
     try:
-        data = json.load(sys.stdin)
-    except:
+        raw = sys.stdin.read()
+        data = json.loads(raw)
+    except Exception:
         return
 
     if data.get("hook_event_name") != "UserPromptSubmit":
@@ -163,19 +161,22 @@ def main():
     if not project_id or not key:
         return
 
-    output_parts = []
+    # 从服务器获取触发配置
+    meta = fetch_rules_meta(api_base, project_id, key)
+    if not meta:
+        return
 
-    # 1. 强制获取 userStyles (用户沟通规则)
-    user_styles = fetch_rules(api_base, project_id, key, "userStyles")
-    if user_styles:
-        output_parts.append(format_rules(user_styles, "用户沟通规则"))
-
-    # 2. 根据关键词匹配额外规则
-    rule, matched = match_rule(user_input_lower)
-    if matched and rule["rule_type"] != "userStyles":
-        extra_rules = fetch_rules(api_base, project_id, key, rule["rule_type"])
-        if extra_rules:
-            output_parts.append(format_rules(extra_rules, rule["label"]))
+    # 匹配所有触发的规则
+    matched = match_all(user_input_lower, meta)
+    if not matched:
+        return
+
+    # 叠加获取所有命中的规则内容
+    output_parts = []
+    for rule_type, label in matched:
+        rules = fetch_rules(api_base, project_id, key, rule_type)
+        if rules:
+            output_parts.append(format_rules(rules, label))
 
     # 输出
     if output_parts: