rules-enforcer 1.0.0

package/detector/knowledge-base/README.md

@@ -0,0 +1,140 @@
+# Knowledge Base - 项目配置知识库
+
+## 目录信息
+
+| 属性 | 值 |
+|------|-----|
+| 名称 | Knowledge Base |
+| 版本 | 1.0.0 |
+| 路径 | `.trae/plugins/project-detector/knowledge-base/` |
+| 插件 | project-detector |
+
+## 目录结构
+
+```
+knowledge-base/
+├── mcp-knowledge.json    # MCP服务知识库
+├── agent-knowledge.json  # Agent配置知识库
+├── rules-knowledge.json # 规则文件知识库
+├── index.js            # 知识库查询接口
+└── kb-verify.js       # 知识库自检脚本
+```
+
+## 功能说明
+
+### 1. MCP服务知识库
+
+存储已知的MCP服务特征信息，用于与项目探测结果匹配：
+
+| 服务ID | 名称 | 类型 | 匹配技术栈 |
+|--------|------|------|-----------|
+| rules-enforcer | Rules Enforcer | rules-engine | javascript, typescript, node.js |
+| custom-hooks | Custom Hooks | hook-gateway | javascript, typescript |
+| context7 | Context7 | context-management | any |
+| sequential-thinking | Sequential Thinking | thinking-chain | any |
+| project-detector | Project Detector | project-scanner | any |
+
+### 2. Agent配置知识库
+
+存储Agent配置模板和推荐规则：
+
+- **全栈开发者**: Node.js + Express.js + React技术栈推荐
+- **后端开发者**: Node.js + Python/Go技术栈推荐
+- **前端开发者**: JavaScript + React/Vue技术栈推荐
+
+### 3. 规则知识库
+
+| 级别 | 数量 | 说明 |
+|------|------|------|
+| L1 | 1 | 用户全局行为约束 |
+| L2 | 1 | 项目特定规则 |
+| L3 | 9 | RZero + custom_config规则 |
+| Custom | 1 | 注意力优化规则 |
+
+## 数据格式
+
+### MCP服务数据结构
+
+```json
+{
+  "id": "service-id",
+  "name": "Service Name",
+  "type": "service-type",
+  "description": "服务描述",
+  "features": ["feature1", "feature2"],
+  "techStackMatch": ["javascript", "typescript"],
+  "projectSizeRange": ["small", "medium", "large"]
+}
+```
+
+### 规则数据结构
+
+```json
+{
+  "id": "rule-id",
+  "name": "Rule Name",
+  "level": "L1/L2/L3/custom",
+  "module": "RZero/custom_config",
+  "type": "rule-type",
+  "description": "规则描述",
+  "priority": 100
+}
+```
+
+## 接口API
+
+### KnowledgeBase类
+
+```javascript
+const { KnowledgeBase } = require('./knowledge-base/index.js');
+const kb = new KnowledgeBase();
+
+// 加载知识库
+kb.load();
+
+// 获取MCP推荐
+kb.recommendMCP(['Node.js', 'Express.js']);
+
+// 获取规则推荐
+kb.recommendRules('medium', existingRules);
+
+// 获取Agent推荐
+kb.recommendAgent(['Node.js', 'Express.js']);
+
+// 生成完整配置建议
+kb.generateRecommendations(projectReport);
+```
+
+## 与project-detector对接
+
+项目探测结束后自动调用知识库：
+
+```javascript
+const detector = new ProjectDetector(projectPath);
+detector.scan();
+
+// 自动获取知识库推荐
+detector.printKnowledgeRecommendations();
+```
+
+## 自检脚本
+
+```bash
+node .trae/plugins/project-detector/knowledge-base/kb-verify.js
+```
+
+### 自检项目
+
+| 检验项 | 内容 |
+|--------|------|
+| 文件完整性 | mcp-knowledge.json, agent-knowledge.json, rules-knowledge.json, index.js |
+| JSON格式 | 三个JSON文件格式校验 |
+| 接口可用性 | load, getMetadata, listMcpServices, listRules, getMcpService, getRule |
+| 跨插件调用 | 与project-detector.js对接测试 |
+| 数据一致性 | metadata与实际数据一致性 |
+
+## 约束
+
+- 知识库存放在 `.trae/plugins/project-detector/knowledge-base/` 目录内
+- 不得独立外置或拆分到其他目录
+- JSON数据必须与project-detector输出的数据结构对应

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

@@ -0,0 +1,62 @@
+{
+  "agents": {
+    "AGENTS.md-root": {
+      "id": "AGENTS.md-root",
+      "name": "Root AGENTS.md",
+      "type": "root-config",
+      "description": "Trae Agent根配置文件，定义全局Agent行为规范",
+      "appliesTo": ["global"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["small", "medium", "large"],
+      "rules": {
+        "L1": true,
+        "L2": true,
+        "L3": true
+      },
+      "mcpDependencies": ["rules-enforcer"],
+      "keywords": ["agents", "root", "config", "global"]
+    },
+    "example-agent": {
+      "id": "example-agent",
+      "name": "Example Agent",
+      "type": "sub-agent",
+      "description": "示例Agent配置，展示子Agent编写规范",
+      "appliesTo": [".trae/agents/"],
+      "techStackMatch": ["any"],
+      "projectSizeRange": ["medium", "large"],
+      "rules": {
+        "L1": true,
+        "L2": true,
+        "L3": false
+      },
+      "mcpDependencies": [],
+      "keywords": ["example", "agent", "sample"]
+    }
+  },
+  "agentProfiles": {
+    "fullstack-developer": {
+      "name": "全栈开发者",
+      "techStack": ["javascript", "typescript", "node.js", "react", "express.js"],
+      "recommendedMcp": ["rules-enforcer", "context7"],
+      "recommendedRules": ["L1", "L2"]
+    },
+    "backend-developer": {
+      "name": "后端开发者",
+      "techStack": ["node.js", "express.js", "python", "go"],
+      "recommendedMcp": ["rules-enforcer", "sequential-thinking"],
+      "recommendedRules": ["L1", "L2", "L3"]
+    },
+    "frontend-developer": {
+      "name": "前端开发者",
+      "techStack": ["javascript", "typescript", "react", "vue.js", "next.js"],
+      "recommendedMcp": ["rules-enforcer", "context7"],
+      "recommendedRules": ["L1", "L2"]
+    }
+  },
+  "metadata": {
+    "version": "1.0.0",
+    "lastUpdated": "2026-06-05",
+    "totalAgents": 2,
+    "totalProfiles": 3
+  }
+}

package/detector/knowledge-base/index.js

@@ -0,0 +1,332 @@
+/**
+ * Knowledge Base Interface for Project Detector
+ * 知识库查询接口，与project-detector.js对接，提供配置推荐
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class KnowledgeBase {
+  constructor(kbPath) {
+    this.kbPath = kbPath || path.join(__dirname);
+    this.mcpKnowledge = null;
+    this.agentKnowledge = null;
+    this.rulesKnowledge = null;
+    this.loaded = false;
+  }
+
+  /**
+   * 加载全部知识库
+   */
+  load() {
+    if (this.loaded) return;
+
+    try {
+      this.mcpKnowledge = JSON.parse(
+        fs.readFileSync(path.join(this.kbPath, 'mcp-knowledge.json'), 'utf8')
+      );
+      this.agentKnowledge = JSON.parse(
+        fs.readFileSync(path.join(this.kbPath, 'agent-knowledge.json'), 'utf8')
+      );
+      this.rulesKnowledge = JSON.parse(
+        fs.readFileSync(path.join(this.kbPath, 'rules-knowledge.json'), 'utf8')
+      );
+      this.loaded = true;
+    } catch (e) {
+      throw new Error(`[KnowledgeBase] 加载失败: ${e.message}`);
+    }
+  }
+
+  /**
+   * 根据技术栈推荐MCP服务
+   */
+  recommendMCP(techStack) {
+    this.load();
+    
+    const recommendations = [];
+    const services = this.mcpKnowledge.mcpServices;
+
+    for (const [id, service] of Object.entries(services)) {
+      const matchScore = this.calculateMatchScore(techStack, service.techStackMatch);
+      if (matchScore > 0) {
+        recommendations.push({
+          id: service.id,
+          name: service.name,
+          type: service.type,
+          description: service.description,
+          matchScore,
+          features: service.features,
+          keywords: service.keywords
+        });
+      }
+    }
+
+    return recommendations.sort((a, b) => b.matchScore - a.matchScore);
+  }
+
+  /**
+   * 根据项目复杂度推荐规则
+   */
+  recommendRules(complexity, existingRules = []) {
+    this.load();
+    
+    const recommendations = [];
+    const rules = this.rulesKnowledge.rules;
+    const recommendations_config = this.rulesKnowledge.ruleRecommendations;
+
+    // 根据复杂度选择推荐配置
+    let configKey = 'simple-project';
+    if (complexity === 'complex') {
+      configKey = 'complex-project';
+    } else if (complexity === 'medium') {
+      configKey = 'simple-project';
+    }
+
+    const config = recommendations_config[configKey];
+    
+    if (config) {
+      for (const ruleId of config.rules) {
+        if (rules[ruleId] && !existingRules.includes(ruleId)) {
+          recommendations.push({
+            id: rules[ruleId].id,
+            name: rules[ruleId].name,
+            level: rules[ruleId].level,
+            module: rules[ruleId].module,
+            description: rules[ruleId].description,
+            priority: rules[ruleId].priority
+          });
+        }
+      }
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * 推荐Agent配置
+   */
+  recommendAgent(techStack) {
+    this.load();
+    
+    const profiles = this.agentKnowledge.agentProfiles;
+    let bestMatch = null;
+    let highestScore = 0;
+
+    for (const [id, profile] of Object.entries(profiles)) {
+      const score = this.calculateMatchScore(techStack, profile.techStack);
+      if (score > highestScore) {
+        highestScore = score;
+        bestMatch = profile;
+      }
+    }
+
+    if (bestMatch) {
+      return {
+        name: bestMatch.name,
+        recommendedMcp: bestMatch.recommendedMcp,
+        recommendedRules: bestMatch.recommendedRules
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * 计算匹配分数
+   */
+  calculateMatchScore(input, patterns) {
+    if (!Array.isArray(input)) {
+      input = [input];
+    }
+    
+    let score = 0;
+    for (const item of input) {
+      const normalizedItem = item.toLowerCase();
+      for (const pattern of patterns) {
+        const normalizedPattern = pattern.toLowerCase();
+        if (normalizedItem === normalizedPattern) {
+          score += 10;
+        } else if (normalizedItem.includes(normalizedPattern)) {
+          score += 5;
+        } else if (normalizedPattern.includes(normalizedItem)) {
+          score += 3;
+        }
+      }
+    }
+    return score;
+  }
+
+  /**
+   * 根据项目探测报告生成完整配置建议
+   */
+  generateRecommendations(projectReport) {
+    this.load();
+
+    const techStack = projectReport.techStack || [];
+    const complexity = projectReport.stats?.complexity || 'simple';
+    const existingMcp = projectReport.existingComponents?.mcp || [];
+    const existingRules = projectReport.existingComponents?.rules || [];
+
+    // 获取推荐
+    const mcpRecommendations = this.recommendMCP(techStack);
+    const rulesRecommendations = this.recommendRules(complexity, existingRules.map(r => r.name));
+    const agentRecommendation = this.recommendAgent(techStack);
+
+    // 过滤已存在的MCP
+    const newMcpRecommendations = mcpRecommendations.filter(
+      mcp => !existingMcp.includes(mcp.id)
+    );
+
+    return {
+      timestamp: new Date().toISOString(),
+      projectAnalysis: {
+        techStack,
+        complexity,
+        existingMcp: existingMcp.length,
+        existingRules: existingRules.length
+      },
+      recommendations: {
+        newMcpServices: newMcpRecommendations,
+        newRules: rulesRecommendations,
+        agentProfile: agentRecommendation
+      },
+      summary: {
+        suggestedMcpCount: newMcpRecommendations.length,
+        suggestedRulesCount: rulesRecommendations.length,
+        hasAgentRecommendation: !!agentRecommendation
+      }
+    };
+  }
+
+  /**
+   * 获取MCP服务详情
+   */
+  getMcpService(mcpId) {
+    this.load();
+    return this.mcpKnowledge.mcpServices[mcpId] || null;
+  }
+
+  /**
+   * 获取规则详情
+   */
+  getRule(ruleId) {
+    this.load();
+    return this.rulesKnowledge.rules[ruleId] || null;
+  }
+
+  /**
+   * 获取全部MCP服务列表
+   */
+  listMcpServices() {
+    this.load();
+    return Object.keys(this.mcpKnowledge.mcpServices);
+  }
+
+  /**
+   * 获取全部规则列表
+   */
+  listRules() {
+    this.load();
+    return Object.values(this.rulesKnowledge.rules);
+  }
+
+  /**
+   * 获取知识库元信息
+   */
+  getMetadata() {
+    this.load();
+    return {
+      mcp: this.mcpKnowledge.metadata,
+      agent: this.agentKnowledge.metadata,
+      rules: this.rulesKnowledge.metadata
+    };
+  }
+
+  /**
+   * 验证知识库完整性
+   */
+  validate() {
+    const errors = [];
+
+    // 检查文件存在
+    const files = ['mcp-knowledge.json', 'agent-knowledge.json', 'rules-knowledge.json'];
+    for (const file of files) {
+      const filePath = path.join(this.kbPath, file);
+      if (!fs.existsSync(filePath)) {
+        errors.push(`文件缺失: ${file}`);
+        continue;
+      }
+
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        JSON.parse(content);
+      } catch (e) {
+        errors.push(`JSON格式错误 ${file}: ${e.message}`);
+      }
+    }
+
+    // 检查知识库内容
+    try {
+      this.load();
+      
+      if (!this.mcpKnowledge.mcpServices) {
+        errors.push('mcp-knowledge.json 缺少 mcpServices 字段');
+      }
+      
+      if (!this.agentKnowledge.agents) {
+        errors.push('agent-knowledge.json 缺少 agents 字段');
+      }
+      
+      if (!this.rulesKnowledge.rules) {
+        errors.push('rules-knowledge.json 缺少 rules 字段');
+      }
+    } catch (e) {
+      errors.push(`知识库加载失败: ${e.message}`);
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+}
+
+// 导出
+module.exports = { KnowledgeBase };
+
+// CLI入口
+if (require.main === module) {
+  const kb = new KnowledgeBase();
+  const validation = kb.validate();
+  
+  console.log('[KnowledgeBase] ========== 知识库验证 ==========');
+  
+  if (validation.valid) {
+    console.log('✅ 知识库验证通过');
+    console.log('\n元信息:');
+    console.log(JSON.stringify(kb.getMetadata(), null, 2));
+    
+    console.log('\n可用MCP服务:');
+    console.log(kb.listMcpServices().join(', '));
+    
+    console.log('\n可用规则:');
+    console.log(`L1: ${kb.listRules().filter(r => r.level === 'L1').map(r => r.name).join(', ')}`);
+    console.log(`L2: ${kb.listRules().filter(r => r.level === 'L2').map(r => r.name).join(', ')}`);
+    console.log(`L3: ${kb.listRules().filter(r => r.level === 'L3').map(r => r.name).join(', ')}`);
+    
+    console.log('\n示例推荐（基于当前项目）:');
+    const { ProjectDetector } = require('./project-detector.js');
+    const detector = new ProjectDetector(process.cwd());
+    detector.scan();
+    const recommendations = kb.generateRecommendations(detector.getReport());
+    console.log(JSON.stringify(recommendations, null, 2));
+    
+    process.exit(0);
+  } else {
+    console.log('❌ 知识库验证失败:');
+    for (const error of validation.errors) {
+      console.log(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+}