rules-enforcer 1.0.0

package/detector/knowledge-base/kb-verify.js

@@ -0,0 +1,287 @@
+/**
+ * Knowledge Base Verification Script
+ * 知识库自检脚本：文件完整性、JSON格式、接口可用性、跨插件调用
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class KBVerifier {
+  constructor() {
+    this.kbDir = path.join(__dirname);
+    this.results = [];
+    this.passed = 0;
+    this.failed = 0;
+  }
+
+  /**
+   * 记录测试结果
+   */
+  log(type, message, status) {
+    const icon = status === 'PASS' ? '✅' : '❌';
+    const log = `${icon} [${type}] ${message}`;
+    this.results.push({ type, message, status });
+    console.log(log);
+    if (status === 'PASS') this.passed++;
+    else this.failed++;
+  }
+
+  /**
+   * 验证1: 文件完整性
+   */
+  verifyFileIntegrity() {
+    console.log('\n[1] 验证文件完整性...');
+    
+    const requiredFiles = [
+      'mcp-knowledge.json',
+      'agent-knowledge.json',
+      'rules-knowledge.json',
+      'index.js'
+    ];
+
+    for (const file of requiredFiles) {
+      const filePath = path.join(this.kbDir, file);
+      if (fs.existsSync(filePath)) {
+        const stats = fs.statSync(filePath);
+        this.log('FILE', `${file} 存在 (${stats.size} bytes)`, 'PASS');
+      } else {
+        this.log('FILE', `${file} 不存在`, 'FAIL');
+      }
+    }
+  }
+
+  /**
+   * 验证2: JSON格式
+   */
+  verifyJsonFormat() {
+    console.log('\n[2] 验证JSON格式...');
+    
+    const jsonFiles = [
+      'mcp-knowledge.json',
+      'agent-knowledge.json',
+      'rules-knowledge.json'
+    ];
+
+    for (const file of jsonFiles) {
+      const filePath = path.join(this.kbDir, file);
+      
+      if (!fs.existsSync(filePath)) {
+        this.log('JSON', `${file} 不存在`, 'FAIL');
+        continue;
+      }
+
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        JSON.parse(content);
+        this.log('JSON', `${file} 格式正确`, 'PASS');
+      } catch (e) {
+        this.log('JSON', `${file} 格式错误: ${e.message}`, 'FAIL');
+      }
+    }
+  }
+
+  /**
+   * 验证3: 接口可用性
+   */
+  verifyInterface() {
+    console.log('\n[3] 验证接口可用性...');
+    
+    try {
+      const { KnowledgeBase } = require('./index.js');
+      const kb = new KnowledgeBase(this.kbDir);
+      
+      // 测试load
+      kb.load();
+      this.log('INTERFACE', 'load() 方法可用', 'PASS');
+
+      // 测试getMetadata
+      const metadata = kb.getMetadata();
+      if (metadata && metadata.mcp && metadata.agent && metadata.rules) {
+        this.log('INTERFACE', 'getMetadata() 返回有效数据', 'PASS');
+      } else {
+        this.log('INTERFACE', 'getMetadata() 返回数据无效', 'FAIL');
+      }
+
+      // 测试listMcpServices
+      const mcpList = kb.listMcpServices();
+      if (Array.isArray(mcpList) && mcpList.length > 0) {
+        this.log('INTERFACE', `listMcpServices() 返回 ${mcpList.length} 个服务`, 'PASS');
+      } else {
+        this.log('INTERFACE', 'listMcpServices() 返回空数组', 'FAIL');
+      }
+
+      // 测试listRules
+      const rulesList = kb.listRules();
+      if (Array.isArray(rulesList) && rulesList.length > 0) {
+        this.log('INTERFACE', `listRules() 返回 ${rulesList.length} 条规则`, 'PASS');
+      } else {
+        this.log('INTERFACE', 'listRules() 返回空数组', 'FAIL');
+      }
+
+      // 测试getMcpService
+      const mcpService = kb.getMcpService('rules-enforcer');
+      if (mcpService && mcpService.name) {
+        this.log('INTERFACE', `getMcpService('rules-enforcer') 返回: ${mcpService.name}`, 'PASS');
+      } else {
+        this.log('INTERFACE', "getMcpService('rules-enforcer') 返回无效", 'FAIL');
+      }
+
+      // 测试getRule
+      const rule = kb.getRule('L1-user-rules');
+      if (rule && rule.name) {
+        this.log('INTERFACE', `getRule('L1-user-rules') 返回: ${rule.name}`, 'PASS');
+      } else {
+        this.log('INTERFACE', "getRule('L1-user-rules') 返回无效", 'FAIL');
+      }
+
+    } catch (e) {
+      this.log('INTERFACE', `接口测试失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 验证4: 跨插件调用
+   */
+  verifyCrossPlugin() {
+    console.log('\n[4] 验证跨插件调用...');
+    
+    try {
+      // 测试与project-detector的对接
+      const { ProjectDetector } = require('../project-detector.js');
+      const { KnowledgeBase } = require('./index.js');
+
+      const detector = new ProjectDetector(process.cwd());
+      detector.scan();
+      
+      const kb = new KnowledgeBase(this.kbDir);
+      const report = detector.getReport();
+      
+      // 生成推荐
+      const recommendations = kb.generateRecommendations(report);
+      
+      if (recommendations && recommendations.recommendations) {
+        this.log('CROSS', 'generateRecommendations() 调用成功', 'PASS');
+        
+        if (recommendations.recommendations.newMcpServices) {
+          this.log('CROSS', `推荐MCP数量: ${recommendations.recommendations.newMcpServices.length}`, 'PASS');
+        }
+        
+        if (recommendations.recommendations.newRules) {
+          this.log('CROSS', `推荐规则数量: ${recommendations.recommendations.newRules.length}`, 'PASS');
+        }
+        
+        if (recommendations.recommendations.agentProfile) {
+          this.log('CROSS', `Agent推荐: ${recommendations.recommendations.agentProfile.name}`, 'PASS');
+        }
+      } else {
+        this.log('CROSS', 'generateRecommendations() 返回无效', 'FAIL');
+      }
+
+      // 测试recommendMCP
+      const mcpRec = kb.recommendMCP(['Node.js', 'Express.js']);
+      if (mcpRec && mcpRec.length > 0) {
+        this.log('CROSS', `recommendMCP(['Node.js', 'Express.js']) 返回 ${mcpRec.length} 个推荐`, 'PASS');
+      } else {
+        this.log('CROSS', 'recommendMCP() 返回空数组', 'FAIL');
+      }
+
+      // 测试recommendRules
+      const rulesRec = kb.recommendRules('medium', []);
+      if (rulesRec && rulesRec.length > 0) {
+        this.log('CROSS', `recommendRules('medium') 返回 ${rulesRec.length} 个推荐`, 'PASS');
+      } else {
+        this.log('CROSS', 'recommendRules() 返回空数组', 'FAIL');
+      }
+
+      // 测试recommendAgent
+      const agentRec = kb.recommendAgent(['Node.js', 'Express.js']);
+      if (agentRec) {
+        this.log('CROSS', `recommendAgent() 返回: ${agentRec.name}`, 'PASS');
+      } else {
+        this.log('CROSS', 'recommendAgent() 返回null', 'FAIL');
+      }
+
+    } catch (e) {
+      this.log('CROSS', `跨插件调用失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 验证5: 数据一致性
+   */
+  verifyDataConsistency() {
+    console.log('\n[5] 验证数据一致性...');
+    
+    try {
+      const { KnowledgeBase } = require('./index.js');
+      const kb = new KnowledgeBase(this.kbDir);
+      kb.load();
+
+      // 检查MCP服务是否包含必要字段
+      const mcpServices = kb.mcpKnowledge.mcpServices;
+      for (const [id, service] of Object.entries(mcpServices)) {
+        const required = ['id', 'name', 'type', 'features', 'techStackMatch'];
+        for (const field of required) {
+          if (!service[field]) {
+            this.log('CONSISTENCY', `MCP服务 ${id} 缺少字段: ${field}`, 'FAIL');
+          }
+        }
+      }
+      this.log('CONSISTENCY', `MCP服务数据结构一致 (${Object.keys(mcpServices).length} 个服务)`, 'PASS');
+
+      // 检查规则是否包含必要字段
+      const rules = kb.rulesKnowledge.rules;
+      for (const [id, rule] of Object.entries(rules)) {
+        const required = ['id', 'name', 'level', 'type'];
+        for (const field of required) {
+          if (!rule[field]) {
+            this.log('CONSISTENCY', `规则 ${id} 缺少字段: ${field}`, 'FAIL');
+          }
+        }
+      }
+      this.log('CONSISTENCY', `规则数据结构一致 (${Object.keys(rules).length} 条规则)`, 'PASS');
+
+      // 检查metadata
+      const metadata = kb.getMetadata();
+      if (metadata.mcp.totalServices === Object.keys(mcpServices).length) {
+        this.log('CONSISTENCY', 'MCP metadata.totalServices 一致', 'PASS');
+      } else {
+        this.log('CONSISTENCY', 'MCP metadata.totalServices 不一致', 'FAIL');
+      }
+
+    } catch (e) {
+      this.log('CONSISTENCY', `数据一致性检查失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 执行全部验证
+   */
+  verifyAll() {
+    console.log('===========================================');
+    console.log('   Knowledge Base Verification');
+    console.log('===========================================');
+
+    this.verifyFileIntegrity();
+    this.verifyJsonFormat();
+    this.verifyInterface();
+    this.verifyCrossPlugin();
+    this.verifyDataConsistency();
+
+    console.log('\n===========================================');
+    console.log(`   验证结果: ${this.passed} 通过, ${this.failed} 失败`);
+    console.log('===========================================');
+
+    if (this.failed > 0) {
+      console.log('\n❌ 知识库验证未全部通过，请检查上述失败项');
+      process.exit(1);
+    } else {
+      console.log('\n✅ 知识库验证全部通过！');
+      process.exit(0);
+    }
+  }
+}
+
+// 执行验证
+const verifier = new KBVerifier();
+verifier.verifyAll();

package/detector/knowledge-base/mcp-knowledge.json

@@ -0,0 +1,135 @@
+{
+  "mcpServices": {
+    "rules-enforcer": {
+      "id": "rules-enforcer",
+      "name": "Rules Enforcer",
+      "type": "rules-engine",
+      "description": "规则引擎校验服务，提供规则加载、验证、执行能力",
+      "features": [
+        "rule-loading",
+        "validation",
+        "rule-execution",
+        "attention-optimization",
+        "l1-rules",
+        "l2-rules",
+        "l3-rules"
+      ],
+      "techStackMatch": [
+        "javascript",
+        "typescript",
+        "node.js",
+        "express.js"
+      ],
+      "projectSizeRange": ["small", "medium", "large"],
+      "dependencies": [],
+      "configPatterns": {
+        "entryPoint": "src/mcp/rules-server.js",
+        "configFile": ".trae/mcp/mcp.json"
+      },
+      "keywords": ["rules", "validation", "enforcement", "attention", "optimization"]
+    },
+    "custom-hooks": {
+      "id": "custom-hooks",
+      "name": "Custom Hooks",
+      "type": "hook-gateway",
+      "description": "MCP网关钩子服务，提供自定义钩子执行能力",
+      "features": [
+        "hook-execution",
+        "pre-processing",
+        "post-processing",
+        "mcp-gateway"
+      ],
+      "techStackMatch": [
+        "javascript",
+        "typescript",
+        "node.js"
+      ],
+      "projectSizeRange": ["small", "medium", "large"],
+      "dependencies": [],
+      "configPatterns": {
+        "entryPoint": ".trae/mcp/custom_hook/custom-hook-server.js",
+        "configFile": ".trae/mcp/mcp.json"
+      },
+      "keywords": ["hooks", "gateway", "custom", "mcp"]
+    },
+    "context7": {
+      "id": "context7",
+      "name": "Context7",
+      "type": "context-management",
+      "description": "上下文管理服务，提供文档检索和上下文管理",
+      "features": [
+        "context-retrieval",
+        "document-search",
+        "context-window"
+      ],
+      "techStackMatch": [
+        "javascript",
+        "typescript",
+        "python",
+        "any"
+      ],
+      "projectSizeRange": ["medium", "large"],
+      "dependencies": [],
+      "configPatterns": {
+        "configFile": ".trae/mcp/mcp.json"
+      },
+      "keywords": ["context", "retrieval", "documents", "search"]
+    },
+    "sequential-thinking": {
+      "id": "sequential-thinking",
+      "name": "Sequential Thinking",
+      "type": "thinking-chain",
+      "description": "链式思维服务，提供顺序推理和思考链管理",
+      "features": [
+        "thinking-chain",
+        "sequential-reasoning",
+        "problem-solving"
+      ],
+      "techStackMatch": [
+        "javascript",
+        "typescript",
+        "any"
+      ],
+      "projectSizeRange": ["small", "medium", "large"],
+      "dependencies": [],
+      "configPatterns": {
+        "configFile": ".trae/mcp/mcp.json"
+      },
+      "keywords": ["thinking", "reasoning", "chain", "sequential"]
+    },
+    "project-detector": {
+      "id": "project-detector",
+      "name": "Project Detector",
+      "type": "project-scanner",
+      "description": "项目探测工具，扫描技术栈、目录拓扑、已有组件",
+      "features": [
+        "tech-stack-detection",
+        "directory-topology",
+        "component-scan",
+        "complexity-assessment"
+      ],
+      "techStackMatch": [
+        "javascript",
+        "typescript",
+        "node.js",
+        "python",
+        "go",
+        "rust",
+        "java",
+        "any"
+      ],
+      "projectSizeRange": ["small", "medium", "large"],
+      "dependencies": [],
+      "configPatterns": {
+        "entryPoint": ".trae/plugins/project-detector/project-detector.js",
+        "configFile": ".trae/plugins/project-detector/plugin.json"
+      },
+      "keywords": ["project", "detector", "scan", "tech-stack", "topology"]
+    }
+  },
+  "metadata": {
+    "version": "1.0.0",
+    "lastUpdated": "2026-06-05",
+    "totalServices": 5
+  }
+}

package/detector/knowledge-base/rules-knowledge.json

@@ -0,0 +1,184 @@
+{
+  "rules": {
+    "L1-user-rules": {
+      "id": "L1-user-rules",
+      "name": "User Rules (L1)",
+      "level": "L1",
+      "type": "global-behavior",
+      "description": "用户全局行为约束，定义代码生成、调试、沟通风格等基础规则",
+      "appliesTo": ["all-projects"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["small", "medium", "large"],
+      "keywords": ["global", "behavior", "coding", "style"],
+      "priority": 100
+    },
+    "L2-project-rules": {
+      "id": "L2-project-rules",
+      "name": "Project Rules (L2)",
+      "level": "L2",
+      "type": "project-specific",
+      "description": "项目特定规则，定义目录结构、命名规范、技术栈约束",
+      "appliesTo": ["current-project"],
+      "techStackMatch": ["node.js", "typescript", "express.js"],
+      "projectSizeRange": ["small", "medium", "large"],
+      "keywords": ["project", "structure", "naming", "convention"],
+      "priority": 200
+    },
+    "L3-RZero-agents": {
+      "id": "L3-RZero-agents",
+      "name": "RZero Agent Configuration",
+      "level": "L3",
+      "module": "RZero",
+      "type": "agent-config",
+      "description": "R-Zero双Agent博弈架构配置，定义Challenger和Solver角色",
+      "appliesTo": ["self-evolution"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["medium", "large"],
+      "keywords": ["R-Zero", "agent", "challenger", "solver", "self-evolution"],
+      "priority": 300
+    },
+    "L3-RZero-base-split": {
+      "id": "L3-RZero-base-split",
+      "name": "RZero Base Split",
+      "level": "L3",
+      "module": "RZero",
+      "type": "problem-split",
+      "description": "问题空间划分策略，控制同源基座拆分初始化",
+      "appliesTo": ["problem-generation"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["medium", "large"],
+      "keywords": ["R-Zero", "base-split", "problem-space"],
+      "priority": 301
+    },
+    "L3-RZero-challenger": {
+      "id": "L3-RZero-challenger",
+      "name": "RZero Challenger Rule",
+      "level": "L3",
+      "module": "RZero",
+      "type": "challenge-generation",
+      "description": "挑战者Agent规则，动态调整问题难度维持45%-55%正确率",
+      "appliesTo": ["difficulty-control"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["medium", "large"],
+      "keywords": ["R-Zero", "challenger", "difficulty", "45-55"],
+      "priority": 302
+    },
+    "L3-RZero-solver": {
+      "id": "L3-RZero-solver",
+      "name": "RZero Solver Rule",
+      "level": "L3",
+      "module": "RZero",
+      "type": "problem-solving",
+      "description": "解题者Agent规则，执行推理与多答自一致性生成伪标签",
+      "appliesTo": ["self-solving"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["medium", "large"],
+      "keywords": ["R-Zero", "solver", "reasoning", "self-consistency"],
+      "priority": 303
+    },
+    "L3-RZero-evolve": {
+      "id": "L3-RZero-evolve",
+      "name": "RZero Evolve Loop",
+      "level": "L3",
+      "module": "RZero",
+      "type": "evolution-loop",
+      "description": "进化循环规则，定义零标注自进化完整闭环",
+      "appliesTo": ["self-evolution"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["medium", "large"],
+      "keywords": ["R-Zero", "evolution", "loop", "zero-data"],
+      "priority": 304
+    },
+    "L3-RZero-mcp": {
+      "id": "L3-RZero-mcp",
+      "name": "RZero MCP Config",
+      "level": "L3",
+      "module": "RZero",
+      "type": "mcp-integration",
+      "description": "MCP持久化配置，定义R-Zero与MCP网关的集成策略",
+      "appliesTo": ["mcp-integration"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["medium", "large"],
+      "keywords": ["R-Zero", "mcp", "persistence", "storage"],
+      "priority": 305
+    },
+    "L3-custom-agent-constraints": {
+      "id": "L3-custom-agent-constraints",
+      "name": "Agent Constraints",
+      "level": "L3",
+      "module": "custom_config",
+      "type": "agent-constraint",
+      "description": "Agent行为约束配置，定义Agent工作边界和安全策略",
+      "appliesTo": ["agent-behavior"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["medium", "large"],
+      "keywords": ["agent", "constraints", "behavior", "security"],
+      "priority": 310
+    },
+    "L3-custom-rules-config": {
+      "id": "L3-custom-rules-config",
+      "name": "Rules Engine Config",
+      "level": "L3",
+      "module": "custom_config",
+      "type": "engine-config",
+      "description": "规则引擎配置，注册注意力优化等自定义规则",
+      "appliesTo": ["rule-loading"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["small", "medium", "large"],
+      "keywords": ["rules", "engine", "attention", "optimization"],
+      "priority": 311
+    },
+    "L3-custom-security": {
+      "id": "L3-custom-security",
+      "name": "Security Constraints",
+      "level": "L3",
+      "module": "custom_config",
+      "type": "security-rule",
+      "description": "安全约束规则，定义代码安全检查和漏洞防范",
+      "appliesTo": ["security-check"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["small", "medium", "large"],
+      "keywords": ["security", "vulnerability", "check", "prevention"],
+      "priority": 312
+    },
+    "custom-attention-optimization": {
+      "id": "custom-attention-optimization",
+      "name": "Attention Optimization Rule",
+      "level": "custom",
+      "module": "attention-optimization",
+      "type": "optimization-rule",
+      "description": "注意力优化规则，管控稀疏注意力、GQA、PagedAttention等优化方案的启用边界",
+      "appliesTo": ["attention-optimization"],
+      "techStackMatch": ["javascript", "typescript", "node.js"],
+      "projectSizeRange": ["medium", "large"],
+      "keywords": ["attention", "optimization", "sparse", "GQA", "PagedAttention"],
+      "priority": 400
+    }
+  },
+  "ruleRecommendations": {
+    "simple-project": {
+      "description": "简单项目推荐配置",
+      "rules": ["L1-user-rules", "L2-project-rules"],
+      "mcp": ["rules-enforcer"]
+    },
+    "complex-project": {
+      "description": "复杂项目推荐配置",
+      "rules": ["L1-user-rules", "L2-project-rules", "L3-RZero-evolve", "L3-custom-security"],
+      "mcp": ["rules-enforcer", "context7", "sequential-thinking"]
+    },
+    "self-evolution": {
+      "description": "自进化项目配置",
+      "rules": ["L1-user-rules", "L2-project-rules", "L3-RZero-agents", "L3-RZero-challenger", "L3-RZero-solver"],
+      "mcp": ["rules-enforcer", "sequential-thinking"]
+    }
+  },
+  "metadata": {
+    "version": "1.0.0",
+    "lastUpdated": "2026-06-05",
+    "totalRules": 12,
+    "l1Count": 1,
+    "l2Count": 1,
+    "l3Count": 9,
+    "customCount": 1
+  }
+}