rules-enforcer 1.0.0

package/detector/decision-engine/de-verify.js

@@ -0,0 +1,461 @@
+/**
+ * Decision Engine Verification Script
+ * 覆盖三类用例：常规项目配置、组件依赖冲突、规则层级冲突
+ */
+
+const path = require('path');
+
+class DEVerifier {
+  constructor() {
+    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: 常规项目配置
+   */
+  testNormalProject() {
+    console.log('\n========== 测试1: 常规项目配置 ==========');
+    
+    try {
+      const { DecisionEngine } = require('./index.js');
+      const { KnowledgeBase } = require('../knowledge-base/index.js');
+      
+      const engine = new DecisionEngine();
+      const kb = new KnowledgeBase(path.join(__dirname, '../knowledge-base'));
+      kb.load();
+      
+      // 模拟常规项目
+      const projectInfo = {
+        techStack: ['Node.js', 'Express.js', 'SQLite'],
+        complexity: 'medium',
+        existingComponents: {
+          mcp: ['rules-enforcer'],
+          agents: [{ name: 'AGENTS.md' }],
+          rules: [{ name: 'user_rules.md', level: 'L1' }]
+        },
+        stats: { complexity: 'medium' }
+      };
+      
+      const decision = engine.decide(kb, projectInfo);
+      
+      // 验证输出结构
+      if (decision.decision && decision.scoreBreakdown && decision.conflicts && decision.alternatives) {
+        this.log('NORMAL', '决策输出结构完整', 'PASS');
+      } else {
+        this.log('NORMAL', '决策输出结构不完整', 'FAIL');
+      }
+      
+      // 验证置信度范围
+      if (decision.decision.confidence >= 0 && decision.decision.confidence <= 1) {
+        this.log('NORMAL', `置信度范围正确: ${decision.decision.confidence}`, 'PASS');
+      } else {
+        this.log('NORMAL', `置信度范围错误: ${decision.decision.confidence}`, 'FAIL');
+      }
+      
+      // 验证分项得分范围
+      const scores = decision.scoreBreakdown;
+      if (scores.techStackMatch >= 0 && scores.techStackMatch <= 100 &&
+          scores.complexityFit >= 0 && scores.complexityFit <= 100 &&
+          scores.dependencyScore >= 0 && scores.dependencyScore <= 100 &&
+          scores.reuseScore >= 0 && scores.reuseScore <= 100) {
+        this.log('NORMAL', '分项得分范围正确 (0~100)', 'PASS');
+      } else {
+        this.log('NORMAL', '分项得分范围错误', 'FAIL');
+      }
+      
+      // 验证权重
+      const weights = engine.optimizer.weights;
+      if (weights.mcp === 0.4 && weights.rules === 0.35 && weights.agent === 0.25) {
+        this.log('NORMAL', '权重配置正确 (MCP=40%, Rules=35%, Agent=25%)', 'PASS');
+      } else {
+        this.log('NORMAL', `权重配置错误: ${JSON.stringify(weights)}`, 'FAIL');
+      }
+
+      // 验证置信度公式：技术栈93、复杂度100、依赖88、复用0
+      // 理论值 = 93*0.4 + 100*0.35 + 88*0.25 = 94.2 -> 0.942
+      const { Optimizer } = require('./optimizer.js');
+      const opt = new Optimizer();
+
+      // 模拟输入数据
+      const mockMcpResult = {
+        recommended: [{
+          scores: { techStackMatch: 93, complexityFit: 100, dependency: 88, reuse: 0 },
+          totalScore: 93
+        }]
+      };
+      const mockRulesResult = {
+        recommended: [{
+          scores: { techStackMatch: 93, complexityFit: 100, dependency: 88, reuse: 0 },
+          totalScore: 93
+        }]
+      };
+      const mockAgentResult = {
+        recommended: {
+          scores: { techStackMatch: 93, complexityFit: 100, dependency: 88, reuse: 0 },
+          totalScore: 93
+        }
+      };
+
+      // 计算置信度
+      const expectedConfidence = 0.942;
+      const actualConfidence = opt.calculateConfidence(mockMcpResult, mockRulesResult, mockAgentResult);
+
+      if (Math.abs(actualConfidence - expectedConfidence) < 0.01) {
+        this.log('NORMAL', `置信度公式验证通过: ${actualConfidence.toFixed(3)} ≈ ${expectedConfidence}`, 'PASS');
+      } else {
+        this.log('NORMAL', `置信度公式错误: 期望${expectedConfidence}, 实际${actualConfidence}`, 'FAIL');
+      }
+
+    } catch (e) {
+      this.log('NORMAL', `测试失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 测试2: 组件依赖冲突
+   */
+  testDependencyConflict() {
+    console.log('\n========== 测试2: 组件依赖冲突 ==========');
+    
+    try {
+      const { ConflictResolver } = require('./conflict-resolver.js');
+      
+      const resolver = new ConflictResolver();
+      
+      // 模拟MCP依赖冲突
+      const mcpServices = [
+        { id: 'service-a', dependencies: ['service-b'] },
+        { id: 'service-b', dependencies: ['service-c'] },
+        { id: 'service-c', dependencies: ['service-a'] } // 循环依赖
+      ];
+      
+      const conflicts = resolver.detectMcpConflicts(mcpServices, []);
+      
+      if (conflicts.some(c => c.type === 'mcp-circular-dependency')) {
+        this.log('DEPENDENCY', '检测到循环依赖', 'PASS');
+      } else {
+        this.log('DEPENDENCY', '未检测到循环依赖', 'FAIL');
+      }
+      
+      // 测试缺失依赖
+      const mcpServices2 = [
+        { id: 'service-x', dependencies: ['non-existent-service'] }
+      ];
+
+      const conflicts2 = resolver.detectMcpConflicts(mcpServices2, []);
+
+      if (conflicts2.some(c => c.type === 'mcp-missing-dependency')) {
+        this.log('DEPENDENCY', '检测到缺失依赖', 'PASS');
+      } else {
+        this.log('DEPENDENCY', '未检测到缺失依赖', 'FAIL');
+      }
+
+      // 测试不兼容依赖
+      const mcpServices3 = [
+        { id: 'service-a', incompatible: ['service-b'] },
+        { id: 'service-b' }
+      ];
+
+      const conflicts3 = resolver.detectMcpConflicts(mcpServices3, []);
+
+      if (conflicts3.some(c => c.type === 'mcp-incompatible-dependency')) {
+        this.log('DEPENDENCY', '检测到不兼容依赖', 'PASS');
+      } else {
+        this.log('DEPENDENCY', '未检测到不兼容依赖', 'FAIL');
+      }
+
+    } catch (e) {
+      this.log('DEPENDENCY', `测试失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 测试3: 规则层级冲突
+   */
+  testRuleConflict() {
+    console.log('\n========== 测试3: 规则层级冲突 ==========');
+    
+    try {
+      const { ConflictResolver } = require('./conflict-resolver.js');
+      
+      const resolver = new ConflictResolver();
+      
+      // 模拟规则冲突
+      const rules = [
+        { id: 'rule-1', name: 'Rule 1', level: 'L1', type: 'behavior', module: 'core' },
+        { id: 'rule-2', name: 'Rule 2', level: 'L1', type: 'behavior', module: 'core' }, // 同类型同优先级
+        { id: 'rule-3', name: 'Rule 3', level: 'L3', type: 'custom', module: 'RZero' }
+      ];
+      
+      const conflicts = resolver.detectRuleConflicts(rules);
+      
+      if (conflicts.some(c => c.type === 'rule-duplicate')) {
+        this.log('RULE', '检测到同类型同优先级规则冲突', 'PASS');
+      } else {
+        this.log('RULE', '未检测到规则冲突', 'FAIL');
+      }
+      
+      // 测试缺失层级
+      const rules2 = [
+        { id: 'rule-l3', name: 'L3 Rule', level: 'L3', type: 'custom', module: 'RZero' }
+      ];
+      
+      const conflicts2 = resolver.detectRuleConflicts(rules2);
+      
+      if (conflicts2.some(c => c.type === 'rule-missing-level')) {
+        this.log('RULE', '检测到缺失L1/L2层级', 'PASS');
+      } else {
+        this.log('RULE', '未检测到缺失层级', 'FAIL');
+      }
+      
+      // 测试规则解决
+      const resolveResult = resolver.resolveRuleConflicts(rules);
+      
+      if (resolveResult.resolved.length > 0 && resolveResult.removed.length > 0) {
+        this.log('RULE', `规则冲突解决成功: 保留${resolveResult.resolved.length}个, 移除${resolveResult.removed.length}个`, 'PASS');
+      } else {
+        this.log('RULE', '规则冲突解决失败', 'FAIL');
+      }
+      
+    } catch (e) {
+      this.log('RULE', `测试失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 测试4: 评分引擎
+   */
+  testScorer() {
+    console.log('\n========== 测试4: 评分引擎 ==========');
+    
+    try {
+      const { Scorer } = require('./scorer.js');
+      
+      const scorer = new Scorer();
+      
+      // 测试技术栈匹配分
+      const techScore = scorer.calculateTechStackMatchScore(
+        ['Node.js', 'Express.js'],
+        ['node.js', 'express.js', 'typescript']
+      );
+      
+      if (techScore >= 0 && techScore <= 100) {
+        this.log('SCORER', `技术栈匹配分: ${techScore}`, 'PASS');
+      } else {
+        this.log('SCORER', `技术栈匹配分范围错误: ${techScore}`, 'FAIL');
+      }
+      
+      // 测试复杂度适配分
+      const complexityScore = scorer.calculateComplexityFitScore('medium', ['small', 'medium', 'large']);
+      
+      if (complexityScore === 100) {
+        this.log('SCORER', `复杂度适配分: ${complexityScore}`, 'PASS');
+      } else {
+        this.log('SCORER', `复杂度适配分错误: ${complexityScore}`, 'FAIL');
+      }
+      
+      // 测试依赖兼容分
+      const depScore = scorer.calculateDependencyScore(
+        ['rules-enforcer'],
+        { mcp: ['rules-enforcer'], agents: [], rules: [] }
+      );
+      
+      if (depScore === 100) {
+        this.log('SCORER', `依赖兼容分: ${depScore}`, 'PASS');
+      } else {
+        this.log('SCORER', `依赖兼容分错误: ${depScore}`, 'FAIL');
+      }
+      
+      // 测试复用分
+      const reuseScore = scorer.calculateReuseScore(
+        'rules-enforcer',
+        { mcp: ['rules-enforcer'], agents: [], rules: [] }
+      );
+      
+      if (reuseScore === 100) {
+        this.log('SCORER', `组件复用分: ${reuseScore}`, 'PASS');
+      } else {
+        this.log('SCORER', `组件复用分错误: ${reuseScore}`, 'FAIL');
+      }
+      
+    } catch (e) {
+      this.log('SCORER', `测试失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 测试5: 优化算法
+   */
+  testOptimizer() {
+    console.log('\n========== 测试5: 优化算法 ==========');
+    
+    try {
+      const { Optimizer } = require('./optimizer.js');
+      
+      const optimizer = new Optimizer();
+      
+      // 模拟知识库
+      const knowledgeBase = {
+        mcpKnowledge: {
+          mcpServices: {
+            'test-mcp': {
+              id: 'test-mcp',
+              name: 'Test MCP',
+              type: 'test',
+              techStackMatch: ['node.js'],
+              projectSizeRange: ['small', 'medium', 'large'],
+              dependencies: []
+            }
+          }
+        },
+        rulesKnowledge: {
+          rules: {
+            'test-rule': {
+              id: 'test-rule',
+              name: 'Test Rule',
+              level: 'L1',
+              type: 'test',
+              techStackMatch: ['any'],
+              projectSizeRange: ['small', 'medium', 'large']
+            }
+          }
+        },
+        agentKnowledge: {
+          agentProfiles: {
+            'test-agent': {
+              name: 'Test Agent',
+              techStack: ['node.js'],
+              recommendedMcp: ['test-mcp'],
+              recommendedRules: ['L1']
+            }
+          }
+        }
+      };
+      
+      const projectInfo = {
+        techStack: ['Node.js'],
+        complexity: 'medium',
+        existingComponents: { mcp: [], agents: [], rules: [] }
+      };
+      
+      const result = optimizer.optimize(knowledgeBase, projectInfo);
+      
+      if (result.mcpResult && result.rulesResult && result.agentResult) {
+        this.log('OPTIMIZER', '优化结果包含三类组件', 'PASS');
+      } else {
+        this.log('OPTIMIZER', '优化结果结构不完整', 'FAIL');
+      }
+      
+      if (result.confidence >= 0 && result.confidence <= 1) {
+        this.log('OPTIMIZER', `置信度计算正确: ${result.confidence.toFixed(2)}`, 'PASS');
+      } else {
+        this.log('OPTIMIZER', `置信度计算错误: ${result.confidence}`, 'FAIL');
+      }
+      
+    } catch (e) {
+      this.log('OPTIMIZER', `测试失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 测试6: 全链路集成
+   */
+  testIntegration() {
+    console.log('\n========== 测试6: 全链路集成 ==========');
+    
+    try {
+      const { DecisionEngine } = require('./index.js');
+      const { KnowledgeBase } = require('../knowledge-base/index.js');
+      const { ProjectDetector } = require('../project-detector.js');
+      
+      // 执行项目探测
+      const detector = new ProjectDetector(process.cwd());
+      detector.scan();
+      const report = detector.getReport();
+      
+      // 加载知识库
+      const kb = new KnowledgeBase(path.join(__dirname, '../knowledge-base'));
+      kb.load();
+      
+      // 执行决策
+      const engine = new DecisionEngine();
+      const decision = engine.decide(kb, report);
+      
+      // 验证完整输出
+      const requiredFields = ['decision', 'scoreBreakdown', 'conflicts', 'alternatives'];
+      const decisionFields = ['recommendedMcp', 'recommendedRules', 'recommendedAgent', 'confidence'];
+      
+      let allFieldsPresent = true;
+      
+      for (const field of requiredFields) {
+        if (!decision[field]) {
+          this.log('INTEGRATION', `缺少字段: ${field}`, 'FAIL');
+          allFieldsPresent = false;
+        }
+      }
+      
+      for (const field of decisionFields) {
+        if (decision.decision[field] === undefined) {
+          this.log('INTEGRATION', `decision缺少字段: ${field}`, 'FAIL');
+          allFieldsPresent = false;
+        }
+      }
+      
+      if (allFieldsPresent) {
+        this.log('INTEGRATION', '全链路集成测试通过', 'PASS');
+      }
+      
+      // 打印决策结果
+      engine.printDecision(decision);
+      
+    } catch (e) {
+      this.log('INTEGRATION', `测试失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 执行全部验证
+   */
+  verifyAll() {
+    console.log('===========================================');
+    console.log('   Decision Engine Verification');
+    console.log('===========================================');
+
+    this.testNormalProject();
+    this.testDependencyConflict();
+    this.testRuleConflict();
+    this.testScorer();
+    this.testOptimizer();
+    this.testIntegration();
+
+    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 DEVerifier();
+verifier.verifyAll();

package/detector/decision-engine/index.js

@@ -0,0 +1,204 @@
+/**
+ * Decision Engine - 决策引擎入口
+ * 对接上层project-detector主程序、下层knowledge-base知识库
+ * 输出最优配置组合建议
+ */
+
+const { Optimizer } = require('./optimizer.js');
+const { ConflictResolver } = require('./conflict-resolver.js');
+
+class DecisionEngine {
+  constructor() {
+    this.optimizer = new Optimizer();
+    this.conflictResolver = new ConflictResolver();
+  }
+
+  /**
+   * 执行决策流程
+   */
+  decide(knowledgeBase, projectReport) {
+    // 构建项目信息
+    const projectInfo = {
+      techStack: projectReport.techStack || [],
+      complexity: projectReport.stats?.complexity || 'medium',
+      existingComponents: projectReport.existingComponents || { mcp: [], agents: [], rules: [] },
+      stats: projectReport.stats || {}
+    };
+
+    // 执行优化
+    const optimizationResult = this.optimizer.optimize(knowledgeBase, projectInfo);
+
+    // 检测冲突
+    const conflictResult = this.conflictResolver.detectAll(optimizationResult, projectInfo);
+
+    // 构建决策输出
+    const decision = this.buildDecision(optimizationResult, conflictResult);
+
+    return decision;
+  }
+
+  /**
+   * 构建决策输出
+   */
+  buildDecision(optimizationResult, conflictResult) {
+    // 提取推荐配置
+    const recommendedMcp = optimizationResult.mcpResult.recommended.map(c => ({
+      id: c.id,
+      name: c.name,
+      type: c.type,
+      score: c.totalScore
+    }));
+
+    const recommendedRules = optimizationResult.rulesResult.recommended.map(c => ({
+      id: c.id,
+      name: c.name,
+      level: c.level,
+      module: c.module,
+      score: c.totalScore
+    }));
+
+    const recommendedAgent = optimizationResult.agentResult.recommended ? {
+      id: optimizationResult.agentResult.recommended.id,
+      name: optimizationResult.agentResult.recommended.name,
+      score: optimizationResult.agentResult.recommended.totalScore,
+      recommendedMcp: optimizationResult.agentResult.recommended.recommendedMcp,
+      recommendedRules: optimizationResult.agentResult.recommended.recommendedRules
+    } : null;
+
+    // 构建最终输出
+    return {
+      decision: {
+        recommendedMcp,
+        recommendedRules,
+        recommendedAgent,
+        confidence: Math.round(optimizationResult.confidence * 100) / 100
+      },
+      scoreBreakdown: optimizationResult.scoreBreakdown,
+      conflicts: conflictResult.conflicts,
+      alternatives: optimizationResult.alternatives
+    };
+  }
+
+  /**
+   * 打印决策结果
+   */
+  printDecision(decision) {
+    console.log('\n========== 决策引擎输出 ==========\n');
+
+    // 置信度
+    console.log(`📊 综合置信度: ${(decision.decision.confidence * 100).toFixed(1)}%`);
+
+    // 分项得分
+    console.log('\n📈 分项得分:');
+    console.log(`   技术栈匹配: ${decision.scoreBreakdown.techStackMatch}/100`);
+    console.log(`   复杂度适配: ${decision.scoreBreakdown.complexityFit}/100`);
+    console.log(`   依赖兼容: ${decision.scoreBreakdown.dependencyScore}/100`);
+    console.log(`   组件复用: ${decision.scoreBreakdown.reuseScore}/100`);
+
+    // MCP推荐
+    console.log('\n📦 推荐MCP服务:');
+    if (decision.decision.recommendedMcp.length === 0) {
+      console.log('   无需新增MCP服务');
+    } else {
+      for (const mcp of decision.decision.recommendedMcp) {
+        console.log(`   - ${mcp.name} (${mcp.type}) - 得分: ${mcp.score}`);
+      }
+    }
+
+    // 规则推荐
+    console.log('\n📋 推荐规则:');
+    if (decision.decision.recommendedRules.length === 0) {
+      console.log('   无需新增规则');
+    } else {
+      for (const rule of decision.decision.recommendedRules) {
+        console.log(`   - ${rule.name} [${rule.level}] - 得分: ${rule.score}`);
+      }
+    }
+
+    // Agent推荐
+    console.log('\n👤 推荐Agent配置:');
+    if (decision.decision.recommendedAgent) {
+      const agent = decision.decision.recommendedAgent;
+      console.log(`   ${agent.name} - 得分: ${agent.score}`);
+      if (agent.recommendedMcp) {
+        console.log(`   推荐MCP: ${agent.recommendedMcp.join(', ')}`);
+      }
+    } else {
+      console.log('   无Agent推荐');
+    }
+
+    // 冲突信息
+    if (decision.conflicts.length > 0) {
+      console.log('\n⚠️ 检测到冲突:');
+      for (const conflict of decision.conflicts) {
+        const icon = conflict.severity === 'error' ? '❌' : 
+                     conflict.severity === 'warning' ? '⚠️' : 'ℹ️';
+        console.log(`   ${icon} [${conflict.type}] ${conflict.message}`);
+        if (conflict.suggestion) {
+          console.log(`      建议: ${conflict.suggestion}`);
+        }
+      }
+    } else {
+      console.log('\n✅ 未检测到冲突');
+    }
+
+    // 备选方案
+    if (decision.alternatives.length > 0) {
+      console.log('\n🔄 备选方案:');
+      for (const alt of decision.alternatives.slice(0, 5)) {
+        console.log(`   - [${alt.type}] ${alt.name} - 得分: ${alt.score}`);
+      }
+    }
+
+    console.log('\n==========================================\n');
+  }
+
+  /**
+   * 获取引擎信息
+   */
+  getInfo() {
+    return {
+      name: 'DecisionEngine',
+      version: '1.0.0',
+      weights: this.optimizer.weights,
+      components: ['Optimizer', 'ConflictResolver', 'Scorer']
+    };
+  }
+}
+
+module.exports = { DecisionEngine };
+
+// CLI入口
+if (require.main === module) {
+  const path = require('path');
+  
+  try {
+    // 加载知识库
+    const { KnowledgeBase } = require('../knowledge-base/index.js');
+    const { ProjectDetector } = require('../project-detector.js');
+    
+    // 执行项目探测
+    const detector = new ProjectDetector(process.cwd());
+    detector.scan();
+    const report = detector.getReport();
+    
+    // 加载知识库
+    const kb = new KnowledgeBase(path.join(__dirname, '..'));
+    kb.load();
+    
+    // 执行决策
+    const engine = new DecisionEngine();
+    const decision = engine.decide(kb, report);
+    
+    // 输出结果
+    engine.printDecision(decision);
+    
+    // 输出JSON
+    console.log('完整决策结果:');
+    console.log(JSON.stringify(decision, null, 2));
+    
+  } catch (e) {
+    console.error('决策引擎执行失败:', e.message);
+    process.exit(1);
+  }
+}