rules-enforcer 1.0.0

package/detector/decision-engine/optimizer.js

@@ -0,0 +1,325 @@
+/**
+ * Optimizer - 优化算法
+ * 基于评分结果生成最优配置组合
+ * 权重固定：MCP=40%, 规则=35%, Agent=25%
+ */
+
+const { Scorer } = require('./scorer.js');
+
+class Optimizer {
+  constructor() {
+    this.scorer = new Scorer();
+    this.weights = this.scorer.getWeights();
+  }
+
+  /**
+   * 优化MCP配置
+   */
+  optimizeMcp(mcpKnowledge, projectInfo) {
+    const scoredComponents = [];
+    const services = mcpKnowledge.mcpServices || {};
+
+    for (const [id, service] of Object.entries(services)) {
+      const score = this.scorer.scoreMcpComponent(service, projectInfo);
+      scoredComponents.push(score);
+    }
+
+    // 按总分降序排序
+    scoredComponents.sort((a, b) => b.totalScore - a.totalScore);
+
+    // 过滤已存在的组件
+    const existingMcp = projectInfo.existingComponents?.mcp || [];
+    const newComponents = scoredComponents.filter(c => 
+      !existingMcp.includes(c.id)
+    );
+
+    // 选择高分组件（最多推荐3个）
+    const recommended = newComponents.slice(0, 3);
+
+    return {
+      all: scoredComponents,
+      recommended,
+      existing: scoredComponents.filter(c => 
+        existingMcp.includes(c.id)
+      )
+    };
+  }
+
+  /**
+   * 优化规则配置
+   */
+  optimizeRules(rulesKnowledge, projectInfo) {
+    const scoredComponents = [];
+    const rules = rulesKnowledge.rules || {};
+
+    for (const [id, rule] of Object.entries(rules)) {
+      const score = this.scorer.scoreRuleComponent(rule, projectInfo);
+      scoredComponents.push(score);
+    }
+
+    // 按优先级和总分排序
+    scoredComponents.sort((a, b) => {
+      // 先按level排序：L1 > L2 > L3 > custom
+      const levelOrder = { 'L1': 1, 'L2': 2, 'L3': 3, 'custom': 4 };
+      const levelDiff = (levelOrder[a.level] || 5) - (levelOrder[b.level] || 5);
+      if (levelDiff !== 0) return levelDiff;
+      
+      // 同级别按总分降序
+      return b.totalScore - a.totalScore;
+    });
+
+    // 过滤已存在的组件
+    const existingRules = (projectInfo.existingComponents?.rules || []).map(r => r.name || r);
+    const newComponents = scoredComponents.filter(c => 
+      !existingRules.includes(c.id) && !existingRules.includes(c.name)
+    );
+
+    // 选择高分组件
+    const recommended = newComponents.slice(0, 5);
+
+    return {
+      all: scoredComponents,
+      recommended,
+      existing: scoredComponents.filter(c => 
+        existingRules.includes(c.id) || existingRules.includes(c.name)
+      )
+    };
+  }
+
+  /**
+   * 优化Agent配置
+   */
+  optimizeAgent(agentKnowledge, projectInfo) {
+    const scoredComponents = [];
+    const profiles = agentKnowledge.agentProfiles || {};
+
+    for (const [id, profile] of Object.entries(profiles)) {
+      const score = this.scorer.scoreAgentComponent({
+        id,
+        ...profile
+      }, projectInfo);
+      scoredComponents.push(score);
+    }
+
+    // 按总分降序排序
+    scoredComponents.sort((a, b) => b.totalScore - a.totalScore);
+
+    // 选择最高分
+    const recommended = scoredComponents[0] || null;
+
+    return {
+      all: scoredComponents,
+      recommended
+    };
+  }
+
+  /**
+   * 计算综合置信度
+   * 基于技术栈匹配度、复杂度适配度、依赖兼容度三项加权
+   * 复用分单独计算，不计入置信度
+   */
+  calculateConfidence(mcpResult, rulesResult, agentResult) {
+    // 提取推荐组件的分项得分
+    const extractScores = (components) => {
+      if (!components || components.length === 0) {
+        return { techStackMatch: 50, complexityFit: 50, dependency: 50 };
+      }
+      const avg = (arr) => arr.reduce((sum, v) => sum + v, 0) / arr.length;
+      return {
+        techStackMatch: avg(components.map(c => c.scores.techStackMatch)),
+        complexityFit: avg(components.map(c => c.scores.complexityFit)),
+        dependency: avg(components.map(c => c.scores.dependency))
+      };
+    };
+
+    const mcpScores = extractScores(mcpResult.recommended);
+    const rulesScores = extractScores(rulesResult.recommended);
+    const agentScores = agentResult.recommended
+      ? {
+          techStackMatch: agentResult.recommended.scores.techStackMatch,
+          complexityFit: agentResult.recommended.scores.complexityFit,
+          dependency: agentResult.recommended.scores.dependency
+        }
+      : { techStackMatch: 50, complexityFit: 50, dependency: 50 };
+
+    // 按固定权重计算综合置信度：技术栈40%、复杂度35%、依赖25%
+    const techStackAvg = mcpScores.techStackMatch * this.weights.mcp +
+                         rulesScores.techStackMatch * this.weights.rules +
+                         agentScores.techStackMatch * this.weights.agent;
+
+    const complexityAvg = mcpScores.complexityFit * this.weights.mcp +
+                          rulesScores.complexityFit * this.weights.rules +
+                          agentScores.complexityFit * this.weights.agent;
+
+    const dependencyAvg = mcpScores.dependency * this.weights.mcp +
+                         rulesScores.dependency * this.weights.rules +
+                         agentScores.dependency * this.weights.agent;
+
+    // 置信度 = 技术栈*0.4 + 复杂度*0.35 + 依赖*0.25
+    const confidence = techStackAvg * this.weights.mcp +
+                       complexityAvg * this.weights.rules +
+                       dependencyAvg * this.weights.agent;
+
+    return Math.round(confidence) / 100; // 转换为0~1区间
+  }
+
+  /**
+   * 计算复用得分（基于已有组件被推荐组件复用的程度）
+   */
+  calculateReuseScore(mcpResult, rulesResult, agentResult) {
+    let reuseCount = 0;
+    let totalCount = 0;
+
+    // MCP复用
+    if (mcpResult.existing && mcpResult.existing.length > 0) {
+      reuseCount += mcpResult.existing.reduce((sum, c) => sum + c.scores.reuse, 0);
+      totalCount += mcpResult.existing.length;
+    }
+
+    // Rules复用
+    if (rulesResult.existing && rulesResult.existing.length > 0) {
+      reuseCount += rulesResult.existing.reduce((sum, c) => sum + c.scores.reuse, 0);
+      totalCount += rulesResult.existing.length;
+    }
+
+    // 如果没有已有组件（全是新增），复用分为0是正常的
+    // 如果有已有组件但复用分为0，说明评分逻辑有问题
+    if (totalCount === 0) {
+      return 0; // 全部是新增组件，复用分为0
+    }
+
+    return Math.round(reuseCount / totalCount);
+  }
+
+  /**
+   * 计算分项得分明细
+   */
+  calculateScoreBreakdown(mcpResult, rulesResult, agentResult) {
+    const extractScores = (components) => {
+      if (!components || components.length === 0) {
+        return { techStackMatch: 50, complexityFit: 50, dependency: 50, reuse: 50 };
+      }
+
+      const avg = (arr) => arr.reduce((sum, v) => sum + v, 0) / arr.length;
+
+      return {
+        techStackMatch: avg(components.map(c => c.scores.techStackMatch)),
+        complexityFit: avg(components.map(c => c.scores.complexityFit)),
+        dependency: avg(components.map(c => c.scores.dependency)),
+        reuse: avg(components.map(c => c.scores.reuse))
+      };
+    };
+
+    const mcpScores = extractScores(mcpResult.recommended);
+    const rulesScores = extractScores(rulesResult.recommended);
+    const agentScores = agentResult.recommended
+      ? agentResult.recommended.scores
+      : { techStackMatch: 50, complexityFit: 50, dependency: 50, reuse: 50 };
+
+    // 综合计算（复用分从已有组件中单独计算）
+    const reuseScore = this.calculateReuseScore(mcpResult, rulesResult, agentResult);
+
+    return {
+      techStackMatch: Math.round(
+        mcpScores.techStackMatch * this.weights.mcp +
+        rulesScores.techStackMatch * this.weights.rules +
+        agentScores.techStackMatch * this.weights.agent
+      ),
+      complexityFit: Math.round(
+        mcpScores.complexityFit * this.weights.mcp +
+        rulesScores.complexityFit * this.weights.rules +
+        agentScores.complexityFit * this.weights.agent
+      ),
+      dependencyScore: Math.round(
+        mcpScores.dependency * this.weights.mcp +
+        rulesScores.dependency * this.weights.rules +
+        agentScores.dependency * this.weights.agent
+      ),
+      reuseScore
+    };
+  }
+
+  /**
+   * 生成备选方案
+   */
+  generateAlternatives(mcpResult, rulesResult, agentResult) {
+    const alternatives = [];
+
+    // MCP备选方案
+    if (mcpResult.all.length > 1) {
+      const mcpAlt = mcpResult.all.slice(1, 3).map(c => ({
+        type: 'mcp',
+        id: c.id,
+        name: c.name,
+        score: c.totalScore
+      }));
+      alternatives.push(...mcpAlt);
+    }
+
+    // 规则备选方案
+    if (rulesResult.all.length > 1) {
+      const rulesAlt = rulesResult.all.slice(1, 4).map(c => ({
+        type: 'rule',
+        id: c.id,
+        name: c.name,
+        level: c.level,
+        score: c.totalScore
+      }));
+      alternatives.push(...rulesAlt);
+    }
+
+    // Agent备选方案
+    if (agentResult.all.length > 1) {
+      const agentAlt = agentResult.all.slice(1, 2).map(c => ({
+        type: 'agent',
+        id: c.id,
+        name: c.name,
+        score: c.totalScore
+      }));
+      alternatives.push(...agentAlt);
+    }
+
+    return alternatives;
+  }
+
+  /**
+   * 执行完整优化
+   */
+  optimize(knowledgeBase, projectInfo) {
+    // 优化各组件
+    const mcpResult = this.optimizeMcp(
+      knowledgeBase.mcpKnowledge,
+      projectInfo
+    );
+
+    const rulesResult = this.optimizeRules(
+      knowledgeBase.rulesKnowledge,
+      projectInfo
+    );
+
+    const agentResult = this.optimizeAgent(
+      knowledgeBase.agentKnowledge,
+      projectInfo
+    );
+
+    // 计算置信度
+    const confidence = this.calculateConfidence(mcpResult, rulesResult, agentResult);
+
+    // 计算分项得分
+    const scoreBreakdown = this.calculateScoreBreakdown(mcpResult, rulesResult, agentResult);
+
+    // 生成备选方案
+    const alternatives = this.generateAlternatives(mcpResult, rulesResult, agentResult);
+
+    return {
+      mcpResult,
+      rulesResult,
+      agentResult,
+      confidence,
+      scoreBreakdown,
+      alternatives
+    };
+  }
+}
+
+module.exports = { Optimizer };

package/detector/decision-engine/scorer.js

@@ -0,0 +1,359 @@
+/**
+ * Scorer - 评分引擎
+ * 四项打分维度：技术栈匹配/复杂度适配/依赖兼容/已有组件复用
+ * 分值区间：0~100
+ */
+
+class Scorer {
+  constructor() {
+    // 固定权重配置（预留外置接口）
+    this.weights = {
+      mcp: 0.40,      // MCP权重 40%
+      rules: 0.35,    // 规则权重 35%
+      agent: 0.25     // Agent权重 25%
+    };
+  }
+
+  /**
+   * 计算技术栈匹配分 (0~100)
+   */
+  calculateTechStackMatchScore(projectTechStack, componentTechStack) {
+    if (!projectTechStack || projectTechStack.length === 0) {
+      return 50; // 无技术栈信息，返回中等分数
+    }
+
+    if (!componentTechStack || componentTechStack.length === 0) {
+      return 50; // 组件无技术栈限制，返回中等分数
+    }
+
+    // 检查是否包含"any"通配符
+    if (componentTechStack.includes('any')) {
+      return 90; // 通用组件，高分
+    }
+
+    let matchCount = 0;
+    let totalScore = 0;
+
+    for (const tech of projectTechStack) {
+      const normalizedTech = tech.toLowerCase();
+      for (const pattern of componentTechStack) {
+        const normalizedPattern = pattern.toLowerCase();
+        
+        if (normalizedTech === normalizedPattern) {
+          totalScore += 100; // 完全匹配
+          matchCount++;
+        } else if (normalizedTech.includes(normalizedPattern)) {
+          totalScore += 80; // 包含匹配
+          matchCount++;
+        } else if (normalizedPattern.includes(normalizedTech)) {
+          totalScore += 70; // 被包含匹配
+          matchCount++;
+        }
+      }
+    }
+
+    if (matchCount === 0) {
+      return 20; // 无匹配，低分
+    }
+
+    return Math.min(100, Math.round(totalScore / matchCount));
+  }
+
+  /**
+   * 计算复杂度适配分 (0~100)
+   */
+  calculateComplexityFitScore(projectComplexity, componentSizeRange) {
+    if (!projectComplexity || !componentSizeRange) {
+      return 50;
+    }
+
+    const complexityMap = {
+      'simple': 1,
+      'medium': 2,
+      'complex': 3
+    };
+
+    const projectLevel = complexityMap[projectComplexity] || 2;
+
+    // 检查组件是否支持该项目规模
+    if (componentSizeRange.includes(projectComplexity)) {
+      return 100; // 完全支持
+    }
+
+    // 检查相邻规模支持
+    const supportedLevels = componentSizeRange.map(s => complexityMap[s] || 2);
+    const minLevel = Math.min(...supportedLevels);
+    const maxLevel = Math.max(...supportedLevels);
+
+    if (projectLevel >= minLevel && projectLevel <= maxLevel) {
+      return 90; // 范围内支持
+    }
+
+    // 计算距离分数
+    const distance = Math.min(
+      Math.abs(projectLevel - minLevel),
+      Math.abs(projectLevel - maxLevel)
+    );
+
+    return Math.max(30, 100 - distance * 25);
+  }
+
+  /**
+   * 计算依赖兼容分 (0~100)
+   */
+  calculateDependencyScore(componentDependencies, existingComponents) {
+    if (!componentDependencies || componentDependencies.length === 0) {
+      return 100; // 无依赖，满分
+    }
+
+    if (!existingComponents) {
+      existingComponents = { mcp: [], agents: [], rules: [] };
+    }
+
+    let satisfiedCount = 0;
+    const allExisting = [
+      ...existingComponents.mcp,
+      ...existingComponents.agents.map(a => a.name || a),
+      ...existingComponents.rules.map(r => r.name || r)
+    ];
+
+    for (const dep of componentDependencies) {
+      if (allExisting.some(e => 
+        (e.id && e.id === dep) || 
+        (e.name && e.name === dep) || 
+        (typeof e === 'string' && e === dep)
+      )) {
+        satisfiedCount++;
+      }
+    }
+
+    if (satisfiedCount === componentDependencies.length) {
+      return 100; // 全部依赖满足
+    }
+
+    return Math.round((satisfiedCount / componentDependencies.length) * 100);
+  }
+
+  /**
+   * 计算复用得分（基于项目已有组件）
+   */
+  calculateReuseScore(componentId, existingComponents) {
+    if (!existingComponents || !componentId) {
+      return 0;
+    }
+
+    // 收集所有已有组件
+    const allExisting = [];
+    
+    // MCP组件（直接是字符串ID数组）
+    if (Array.isArray(existingComponents.mcp)) {
+      allExisting.push(...existingComponents.mcp);
+    }
+    
+    // Agent组件（可能是对象数组）
+    if (Array.isArray(existingComponents.agents)) {
+      for (const agent of existingComponents.agents) {
+        if (typeof agent === 'string') {
+          allExisting.push(agent);
+        } else if (agent.name) {
+          allExisting.push(agent.name);
+        } else if (agent.id) {
+          allExisting.push(agent.id);
+        }
+      }
+    }
+    
+    // Rule组件（可能是对象数组）
+    if (Array.isArray(existingComponents.rules)) {
+      for (const rule of existingComponents.rules) {
+        if (typeof rule === 'string') {
+          allExisting.push(rule);
+        } else if (rule.name) {
+          allExisting.push(rule.name);
+        } else if (rule.id) {
+          allExisting.push(rule.id);
+        }
+      }
+    }
+
+    // 精确匹配或ID部分匹配
+    const normalizedId = componentId.toLowerCase();
+    for (const existing of allExisting) {
+      if (typeof existing === 'string') {
+        const normalizedExisting = existing.toLowerCase();
+        // 精确匹配
+        if (normalizedExisting === normalizedId) {
+          return 100;
+        }
+        // 包含匹配（如 'rules-enforcer' 匹配 'rules-enforcer-mcp'）
+        if (normalizedId.includes(normalizedExisting) || normalizedExisting.includes(normalizedId)) {
+          return 100;
+        }
+      }
+    }
+
+    return 0; // 不存在，0分
+  }
+
+  /**
+   * 计算MCP组件综合分
+   */
+  scoreMcpComponent(mcpComponent, projectInfo) {
+    const techStackScore = this.calculateTechStackMatchScore(
+      projectInfo.techStack,
+      mcpComponent.techStackMatch
+    );
+
+    const complexityScore = this.calculateComplexityFitScore(
+      projectInfo.complexity,
+      mcpComponent.projectSizeRange
+    );
+
+    const dependencyScore = this.calculateDependencyScore(
+      mcpComponent.dependencies,
+      projectInfo.existingComponents
+    );
+
+    const reuseScore = this.calculateReuseScore(
+      mcpComponent.id,
+      projectInfo.existingComponents
+    );
+
+    // 综合分 = (技术栈*0.4 + 复杂度*0.3 + 依赖*0.2 + 复用*0.1)
+    const totalScore = Math.round(
+      techStackScore * 0.4 +
+      complexityScore * 0.3 +
+      dependencyScore * 0.2 +
+      reuseScore * 0.1
+    );
+
+    return {
+      id: mcpComponent.id,
+      name: mcpComponent.name,
+      type: mcpComponent.type,
+      scores: {
+        techStackMatch: techStackScore,
+        complexityFit: complexityScore,
+        dependency: dependencyScore,
+        reuse: reuseScore
+      },
+      totalScore,
+      weight: this.weights.mcp
+    };
+  }
+
+  /**
+   * 计算规则组件综合分
+   */
+  scoreRuleComponent(ruleComponent, projectInfo) {
+    const techStackScore = this.calculateTechStackMatchScore(
+      projectInfo.techStack,
+      ruleComponent.techStackMatch
+    );
+
+    const complexityScore = this.calculateComplexityFitScore(
+      projectInfo.complexity,
+      ruleComponent.projectSizeRange
+    );
+
+    const reuseScore = this.calculateReuseScore(
+      ruleComponent.id,
+      projectInfo.existingComponents
+    );
+
+    // 规则通常无依赖
+    const dependencyScore = 100;
+
+    // 综合分 = (技术栈*0.4 + 复杂度*0.3 + 依赖*0.1 + 复用*0.2)
+    const totalScore = Math.round(
+      techStackScore * 0.4 +
+      complexityScore * 0.3 +
+      dependencyScore * 0.1 +
+      reuseScore * 0.2
+    );
+
+    return {
+      id: ruleComponent.id,
+      name: ruleComponent.name,
+      level: ruleComponent.level,
+      module: ruleComponent.module,
+      scores: {
+        techStackMatch: techStackScore,
+        complexityFit: complexityScore,
+        dependency: dependencyScore,
+        reuse: reuseScore
+      },
+      totalScore,
+      weight: this.weights.rules
+    };
+  }
+
+  /**
+   * 计算Agent组件综合分
+   */
+  scoreAgentComponent(agentComponent, projectInfo) {
+    const techStackScore = this.calculateTechStackMatchScore(
+      projectInfo.techStack,
+      agentComponent.techStack
+    );
+
+    const complexityScore = this.calculateComplexityFitScore(
+      projectInfo.complexity,
+      agentComponent.projectSizeRange || ['small', 'medium', 'large']
+    );
+
+    const dependencyScore = this.calculateDependencyScore(
+      agentComponent.recommendedMcp,
+      projectInfo.existingComponents
+    );
+
+    const reuseScore = this.calculateReuseScore(
+      agentComponent.id,
+      projectInfo.existingComponents
+    );
+
+    // 综合分 = (技术栈*0.5 + 复杂度*0.2 + 依赖*0.2 + 复用*0.1)
+    const totalScore = Math.round(
+      techStackScore * 0.5 +
+      complexityScore * 0.2 +
+      dependencyScore * 0.2 +
+      reuseScore * 0.1
+    );
+
+    return {
+      id: agentComponent.id,
+      name: agentComponent.name,
+      scores: {
+        techStackMatch: techStackScore,
+        complexityFit: complexityScore,
+        dependency: dependencyScore,
+        reuse: reuseScore
+      },
+      totalScore,
+      weight: this.weights.agent
+    };
+  }
+
+  /**
+   * 获取当前权重配置
+   */
+  getWeights() {
+    return { ...this.weights };
+  }
+
+  /**
+   * 设置权重配置（预留外置接口）
+   */
+  setWeights(newWeights) {
+    // 验证权重总和为1
+    const sum = (newWeights.mcp || 0) + (newWeights.rules || 0) + (newWeights.agent || 0);
+    if (Math.abs(sum - 1) > 0.001) {
+      throw new Error(`权重总和必须为1，当前总和: ${sum}`);
+    }
+    
+    this.weights = { ...newWeights };
+    return this.weights;
+  }
+}
+
+module.exports = { Scorer };