rules-enforcer 1.0.0

package/detector/decision-engine/conflict-resolver.js

@@ -0,0 +1,336 @@
+/**
+ * Conflict Resolver - 冲突解决器
+ * 检测规则优先级冲突、MCP依赖冲突、资源冲突
+ * 优先级规则：L1 > L2 > L3 > custom
+ */
+
+class ConflictResolver {
+  constructor() {
+    // 规则优先级定义
+    this.rulePriority = {
+      'L1': 1,    // 最高优先级
+      'L2': 2,
+      'L3': 3,
+      'custom': 4  // 最低优先级
+    };
+  }
+
+  /**
+   * 检测规则层级冲突
+   */
+  detectRuleConflicts(rules) {
+    const conflicts = [];
+
+    if (!rules || rules.length === 0) {
+      return conflicts;
+    }
+
+    // 按模块分组
+    const moduleGroups = {};
+    for (const rule of rules) {
+      const module = rule.module || 'default';
+      if (!moduleGroups[module]) {
+        moduleGroups[module] = [];
+      }
+      moduleGroups[module].push(rule);
+    }
+
+    // 检查同一模块内的规则冲突
+    for (const [module, moduleRules] of Object.entries(moduleGroups)) {
+      // 检查是否有重复功能的规则
+      const typeMap = {};
+      for (const rule of moduleRules) {
+        const type = rule.type || 'unknown';
+        if (typeMap[type]) {
+          // 同类型规则，检查优先级
+          const existing = typeMap[type];
+          const existingPriority = this.rulePriority[existing.level] || 5;
+          const currentPriority = this.rulePriority[rule.level] || 5;
+
+          if (existingPriority === currentPriority) {
+            conflicts.push({
+              type: 'rule-duplicate',
+              severity: 'warning',
+              message: `模块 ${module} 中存在同类型同优先级规则`,
+              components: [existing.id, rule.id],
+              suggestion: '建议保留其中一个规则'
+            });
+          }
+        } else {
+          typeMap[type] = rule;
+        }
+      }
+    }
+
+    // 检查L1/L2/L3层级覆盖
+    const levels = {};
+    for (const rule of rules) {
+      const level = rule.level;
+      if (!levels[level]) {
+        levels[level] = [];
+      }
+      levels[level].push(rule);
+    }
+
+    // 检查是否缺少必要层级
+    if (!levels['L1'] && (levels['L2'] || levels['L3'])) {
+      conflicts.push({
+        type: 'rule-missing-level',
+        severity: 'info',
+        message: '缺少L1全局规则，建议添加用户全局行为约束',
+        suggestion: '添加 user_rules.md (L1)'
+      });
+    }
+
+    if (!levels['L2'] && levels['L3']) {
+      conflicts.push({
+        type: 'rule-missing-level',
+        severity: 'info',
+        message: '缺少L2项目规则，建议添加项目特定约束',
+        suggestion: '添加 project_rules.md (L2)'
+      });
+    }
+
+    return conflicts;
+  }
+
+  /**
+   * 检测MCP依赖冲突
+   */
+  detectMcpConflicts(mcpServices, existingMcp) {
+    const conflicts = [];
+
+    if (!mcpServices || mcpServices.length === 0) {
+      return conflicts;
+    }
+
+    // 构建依赖图
+    const dependencyGraph = {};
+    for (const service of mcpServices) {
+      dependencyGraph[service.id] = service.dependencies || [];
+    }
+
+    // 检查循环依赖
+    const visited = new Set();
+    const recursionStack = new Set();
+
+    const hasCycle = (node, path) => {
+      visited.add(node);
+      recursionStack.add(node);
+
+      const deps = dependencyGraph[node] || [];
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          if (hasCycle(dep, [...path, dep])) {
+            return true;
+          }
+        } else if (recursionStack.has(dep)) {
+          conflicts.push({
+            type: 'mcp-circular-dependency',
+            severity: 'error',
+            message: `检测到MCP循环依赖: ${[...path, dep].join(' -> ')}`,
+            components: [...path, dep],
+            suggestion: '请移除循环依赖'
+          });
+          return true;
+        }
+      }
+
+      recursionStack.delete(node);
+      return false;
+    };
+
+    for (const serviceId of Object.keys(dependencyGraph)) {
+      if (!visited.has(serviceId)) {
+        hasCycle(serviceId, [serviceId]);
+      }
+    }
+
+    // 检查缺失依赖
+    for (const service of mcpServices) {
+      const deps = service.dependencies || [];
+      for (const dep of deps) {
+        const depExists = existingMcp.includes(dep) ||
+          mcpServices.some(s => s.id === dep);
+
+        if (!depExists) {
+          conflicts.push({
+            type: 'mcp-missing-dependency',
+            severity: 'warning',
+            message: `MCP服务 ${service.id} 依赖 ${dep}，但该依赖不存在`,
+            components: [service.id, dep],
+            suggestion: `请先安装或启用 ${dep} 服务`
+          });
+        }
+      }
+
+      // 检查不兼容依赖
+      const incompatible = service.incompatible || [];
+      for (const inc of incompatible) {
+        const incExists = existingMcp.includes(inc) ||
+          mcpServices.some(s => s.id === inc);
+
+        if (incExists) {
+          conflicts.push({
+            type: 'mcp-incompatible-dependency',
+            severity: 'error',
+            message: `MCP服务 ${service.id} 与 ${inc} 存在功能冲突`,
+            components: [service.id, inc],
+            suggestion: `请勿同时启用 ${service.id} 和 ${inc}`
+          });
+        }
+      }
+    }
+
+    return conflicts;
+  }
+
+  /**
+   * 检测资源冲突
+   */
+  detectResourceConflicts(components, projectInfo) {
+    const conflicts = [];
+
+    // 检查内存/CPU限制（简化版）
+    const mcpCount = components.mcp?.length || 0;
+    const ruleCount = components.rules?.length || 0;
+    const complexity = projectInfo.complexity || 'medium';
+
+    // 根据项目复杂度检查组件数量
+    const limits = {
+      simple: { mcp: 3, rules: 5 },
+      medium: { mcp: 5, rules: 10 },
+      complex: { mcp: 10, rules: 20 }
+    };
+
+    const limit = limits[complexity] || limits.medium;
+
+    if (mcpCount > limit.mcp) {
+      conflicts.push({
+        type: 'resource-mcp-overload',
+        severity: 'warning',
+        message: `MCP服务数量(${mcpCount})超过${complexity}项目建议上限(${limit.mcp})`,
+        suggestion: '考虑禁用部分非必要MCP服务'
+      });
+    }
+
+    if (ruleCount > limit.rules) {
+      conflicts.push({
+        type: 'resource-rules-overload',
+        severity: 'warning',
+        message: `规则数量(${ruleCount})超过${complexity}项目建议上限(${limit.rules})`,
+        suggestion: '考虑合并或移除部分规则'
+      });
+    }
+
+    return conflicts;
+  }
+
+  /**
+   * 检测Agent配置冲突
+   */
+  detectAgentConflicts(agentProfile, existingAgents) {
+    const conflicts = [];
+
+    if (!agentProfile) {
+      return conflicts;
+    }
+
+    // 检查Agent推荐的MCP是否存在
+    const recommendedMcp = agentProfile.recommendedMcp || [];
+    const existingMcp = existingAgents.mcp || [];
+
+    for (const mcp of recommendedMcp) {
+      if (!existingMcp.includes(mcp)) {
+        conflicts.push({
+          type: 'agent-mcp-missing',
+          severity: 'info',
+          message: `Agent配置 ${agentProfile.name} 推荐的MCP服务 ${mcp} 未安装`,
+          suggestion: `考虑安装 ${mcp} 服务以获得最佳体验`
+        });
+      }
+    }
+
+    return conflicts;
+  }
+
+  /**
+   * 解决规则冲突（按优先级保留）
+   */
+  resolveRuleConflicts(rules) {
+    if (!rules || rules.length === 0) {
+      return { resolved: [], removed: [] };
+    }
+
+    // 按优先级排序
+    const sorted = [...rules].sort((a, b) => {
+      const priorityA = this.rulePriority[a.level] || 5;
+      const priorityB = this.rulePriority[b.level] || 5;
+      return priorityA - priorityB; // 低数字优先
+    });
+
+    // 去重（保留高优先级）
+    const seen = new Set();
+    const resolved = [];
+    const removed = [];
+
+    for (const rule of sorted) {
+      const key = `${rule.module || 'default'}-${rule.type || 'unknown'}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        resolved.push(rule);
+      } else {
+        removed.push(rule);
+      }
+    }
+
+    return { resolved, removed };
+  }
+
+  /**
+   * 执行完整冲突检测
+   */
+  detectAll(optimizationResult, projectInfo) {
+    const allConflicts = [];
+
+    // 规则冲突检测
+    const rules = optimizationResult.rulesResult?.all || [];
+    const ruleConflicts = this.detectRuleConflicts(rules);
+    allConflicts.push(...ruleConflicts);
+
+    // MCP依赖冲突检测
+    const mcpServices = optimizationResult.mcpResult?.all || [];
+    const existingMcp = projectInfo.existingComponents?.mcp || [];
+    const mcpConflicts = this.detectMcpConflicts(mcpServices, existingMcp);
+    allConflicts.push(...mcpConflicts);
+
+    // 资源冲突检测
+    const components = {
+      mcp: mcpServices,
+      rules: rules
+    };
+    const resourceConflicts = this.detectResourceConflicts(components, projectInfo);
+    allConflicts.push(...resourceConflicts);
+
+    // Agent冲突检测
+    const agentProfile = optimizationResult.agentResult?.recommended;
+    const agentConflicts = this.detectAgentConflicts(agentProfile, projectInfo.existingComponents || {});
+    allConflicts.push(...agentConflicts);
+
+    // 统计冲突严重程度
+    const summary = {
+      error: allConflicts.filter(c => c.severity === 'error').length,
+      warning: allConflicts.filter(c => c.severity === 'warning').length,
+      info: allConflicts.filter(c => c.severity === 'info').length
+    };
+
+    return {
+      conflicts: allConflicts,
+      summary,
+      hasErrors: summary.error > 0,
+      hasWarnings: summary.warning > 0
+    };
+  }
+}
+
+module.exports = { ConflictResolver };