@vibecheckai/cli 3.2.5 → 3.3.0

package/mcp-server/conductor/conflict-resolver.js

@@ -0,0 +1,588 @@
+/**
+ * Conductor Conflict Resolver
+ * 
+ * Builds cross-agent assumption graphs and detects conflicts
+ * between multiple AI agents working on the same codebase.
+ * 
+ * Codename: Conductor
+ */
+
+"use strict";
+
+import path from "path";
+
+/**
+ * Conflict types
+ */
+const CONFLICT_TYPES = {
+  SAME_FILE: "same_file",           // Multiple agents modifying same file
+  DEPENDENT_ASSUMPTION: "dependent_assumption",  // Agent B depends on what A assumes
+  INCOMPATIBLE_OPERATION: "incompatible_operation", // Operations that can't coexist
+  RESOURCE_CONTENTION: "resource_contention",   // Competing for same resource
+  ORDER_DEPENDENCY: "order_dependency",  // A must complete before B
+};
+
+/**
+ * Conflict severity levels
+ */
+const CONFLICT_SEVERITY = {
+  CRITICAL: "critical",   // Must be resolved before proceeding
+  HIGH: "high",           // Strongly recommended to resolve
+  MEDIUM: "medium",       // Can proceed with caution
+  LOW: "low",             // Advisory only
+};
+
+/**
+ * Resolution strategies
+ */
+const RESOLUTION_STRATEGIES = {
+  QUEUE: "queue",         // Queue operations sequentially
+  MERGE: "merge",         // Attempt to merge operations
+  REJECT: "reject",       // Reject conflicting operation
+  DEFER: "defer",         // Defer to higher priority agent
+};
+
+/**
+ * @typedef {Object} Proposal
+ * @property {string} proposalId - Unique proposal ID
+ * @property {string} sessionId - Session that owns this proposal
+ * @property {string} agentId - Agent that created this proposal
+ * @property {string} intent - What the agent intends to do
+ * @property {Object[]} operations - List of operations
+ * @property {Object[]} assumptions - Assumptions made by the agent
+ * @property {Date} createdAt - When proposal was created
+ */
+
+/**
+ * @typedef {Object} Conflict
+ * @property {string} type - Conflict type
+ * @property {string} severity - Conflict severity
+ * @property {string} proposalA - First proposal ID
+ * @property {string} proposalB - Second proposal ID
+ * @property {string} description - Human-readable description
+ * @property {Object} details - Additional details
+ * @property {string[]} suggestedResolutions - Possible resolution strategies
+ */
+
+/**
+ * @typedef {Object} AssumptionNode
+ * @property {string} proposalId - Proposal making this assumption
+ * @property {string} type - Assumption type (file_exists, route_exists, etc.)
+ * @property {string} target - What the assumption is about
+ * @property {*} expectedValue - Expected state
+ */
+
+/**
+ * Conflict Resolver class
+ */
+class ConflictResolver {
+  constructor() {
+    this.proposals = new Map(); // proposalId -> Proposal
+    this.assumptionGraph = new Map(); // target -> AssumptionNode[]
+    this.conflicts = [];
+    this.resolutions = new Map(); // conflictId -> Resolution
+  }
+  
+  /**
+   * Add a proposal for conflict analysis
+   * @param {Proposal} proposal - Proposal to add
+   */
+  addProposal(proposal) {
+    this.proposals.set(proposal.proposalId, {
+      ...proposal,
+      addedAt: new Date(),
+    });
+    
+    // Index assumptions
+    this.indexAssumptions(proposal);
+    
+    // Detect conflicts with existing proposals
+    this.detectConflicts(proposal);
+  }
+  
+  /**
+   * Remove a proposal
+   * @param {string} proposalId - Proposal ID to remove
+   */
+  removeProposal(proposalId) {
+    const proposal = this.proposals.get(proposalId);
+    if (!proposal) return;
+    
+    // Remove from assumption graph
+    this.removeAssumptions(proposal);
+    
+    // Remove conflicts involving this proposal
+    this.conflicts = this.conflicts.filter(
+      c => c.proposalA !== proposalId && c.proposalB !== proposalId
+    );
+    
+    this.proposals.delete(proposalId);
+  }
+  
+  /**
+   * Index a proposal's assumptions in the graph
+   * @param {Proposal} proposal - Proposal to index
+   */
+  indexAssumptions(proposal) {
+    for (const assumption of proposal.assumptions || []) {
+      const target = this.normalizeTarget(assumption.target || assumption.path);
+      
+      if (!this.assumptionGraph.has(target)) {
+        this.assumptionGraph.set(target, []);
+      }
+      
+      this.assumptionGraph.get(target).push({
+        proposalId: proposal.proposalId,
+        type: assumption.type,
+        target,
+        expectedValue: assumption.expectedValue || assumption.value,
+      });
+    }
+  }
+  
+  /**
+   * Remove a proposal's assumptions from the graph
+   * @param {Proposal} proposal - Proposal to remove
+   */
+  removeAssumptions(proposal) {
+    for (const [target, nodes] of this.assumptionGraph) {
+      const filtered = nodes.filter(n => n.proposalId !== proposal.proposalId);
+      if (filtered.length === 0) {
+        this.assumptionGraph.delete(target);
+      } else {
+        this.assumptionGraph.set(target, filtered);
+      }
+    }
+  }
+  
+  /**
+   * Normalize a target path/identifier
+   * @param {string} target - Target to normalize
+   * @returns {string} Normalized target
+   */
+  normalizeTarget(target) {
+    if (!target) return "";
+    return path.resolve(target).replace(/\\/g, "/").toLowerCase();
+  }
+  
+  /**
+   * Detect conflicts between a new proposal and existing ones
+   * @param {Proposal} newProposal - New proposal to check
+   */
+  detectConflicts(newProposal) {
+    for (const [proposalId, existingProposal] of this.proposals) {
+      if (proposalId === newProposal.proposalId) continue;
+      if (existingProposal.sessionId === newProposal.sessionId) continue;
+      
+      // Check for same-file conflicts
+      const fileConflicts = this.detectSameFileConflicts(newProposal, existingProposal);
+      this.conflicts.push(...fileConflicts);
+      
+      // Check for dependent assumption conflicts
+      const assumptionConflicts = this.detectAssumptionConflicts(newProposal, existingProposal);
+      this.conflicts.push(...assumptionConflicts);
+      
+      // Check for incompatible operations
+      const operationConflicts = this.detectOperationConflicts(newProposal, existingProposal);
+      this.conflicts.push(...operationConflicts);
+    }
+  }
+  
+  /**
+   * Detect same-file modification conflicts
+   * @param {Proposal} proposalA - First proposal
+   * @param {Proposal} proposalB - Second proposal
+   * @returns {Conflict[]} Detected conflicts
+   */
+  detectSameFileConflicts(proposalA, proposalB) {
+    const conflicts = [];
+    
+    const filesA = this.extractAffectedFiles(proposalA);
+    const filesB = this.extractAffectedFiles(proposalB);
+    
+    // Find overlapping files
+    for (const fileA of filesA) {
+      const normalizedA = this.normalizeTarget(fileA.path);
+      
+      for (const fileB of filesB) {
+        const normalizedB = this.normalizeTarget(fileB.path);
+        
+        if (normalizedA === normalizedB) {
+          const conflict = {
+            id: `conflict_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            type: CONFLICT_TYPES.SAME_FILE,
+            severity: this.calculateFileSeverity(fileA, fileB),
+            proposalA: proposalA.proposalId,
+            proposalB: proposalB.proposalId,
+            description: `Both proposals modify ${fileA.path}`,
+            details: {
+              file: fileA.path,
+              operationA: fileA.operation,
+              operationB: fileB.operation,
+            },
+            suggestedResolutions: this.suggestResolutions(CONFLICT_TYPES.SAME_FILE, fileA, fileB),
+          };
+          
+          conflicts.push(conflict);
+        }
+      }
+    }
+    
+    return conflicts;
+  }
+  
+  /**
+   * Detect conflicts from dependent assumptions
+   * @param {Proposal} proposalA - First proposal
+   * @param {Proposal} proposalB - Second proposal
+   * @returns {Conflict[]} Detected conflicts
+   */
+  detectAssumptionConflicts(proposalA, proposalB) {
+    const conflicts = [];
+    
+    // Check if A's operations would invalidate B's assumptions
+    for (const opA of proposalA.operations || []) {
+      for (const assumptionB of proposalB.assumptions || []) {
+        if (this.operationInvalidatesAssumption(opA, assumptionB)) {
+          conflicts.push({
+            id: `conflict_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            type: CONFLICT_TYPES.DEPENDENT_ASSUMPTION,
+            severity: CONFLICT_SEVERITY.HIGH,
+            proposalA: proposalA.proposalId,
+            proposalB: proposalB.proposalId,
+            description: `${proposalA.agentId}'s changes would invalidate ${proposalB.agentId}'s assumption`,
+            details: {
+              operation: opA,
+              assumption: assumptionB,
+            },
+            suggestedResolutions: [RESOLUTION_STRATEGIES.QUEUE, RESOLUTION_STRATEGIES.REJECT],
+          });
+        }
+      }
+    }
+    
+    // Check the reverse
+    for (const opB of proposalB.operations || []) {
+      for (const assumptionA of proposalA.assumptions || []) {
+        if (this.operationInvalidatesAssumption(opB, assumptionA)) {
+          conflicts.push({
+            id: `conflict_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            type: CONFLICT_TYPES.DEPENDENT_ASSUMPTION,
+            severity: CONFLICT_SEVERITY.HIGH,
+            proposalA: proposalB.proposalId,
+            proposalB: proposalA.proposalId,
+            description: `${proposalB.agentId}'s changes would invalidate ${proposalA.agentId}'s assumption`,
+            details: {
+              operation: opB,
+              assumption: assumptionA,
+            },
+            suggestedResolutions: [RESOLUTION_STRATEGIES.QUEUE, RESOLUTION_STRATEGIES.REJECT],
+          });
+        }
+      }
+    }
+    
+    return conflicts;
+  }
+  
+  /**
+   * Detect incompatible operation conflicts
+   * @param {Proposal} proposalA - First proposal
+   * @param {Proposal} proposalB - Second proposal
+   * @returns {Conflict[]} Detected conflicts
+   */
+  detectOperationConflicts(proposalA, proposalB) {
+    const conflicts = [];
+    
+    for (const opA of proposalA.operations || []) {
+      for (const opB of proposalB.operations || []) {
+        if (this.operationsIncompatible(opA, opB)) {
+          conflicts.push({
+            id: `conflict_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            type: CONFLICT_TYPES.INCOMPATIBLE_OPERATION,
+            severity: CONFLICT_SEVERITY.CRITICAL,
+            proposalA: proposalA.proposalId,
+            proposalB: proposalB.proposalId,
+            description: "Operations cannot coexist",
+            details: {
+              operationA: opA,
+              operationB: opB,
+              reason: this.getIncompatibilityReason(opA, opB),
+            },
+            suggestedResolutions: [RESOLUTION_STRATEGIES.REJECT, RESOLUTION_STRATEGIES.DEFER],
+          });
+        }
+      }
+    }
+    
+    return conflicts;
+  }
+  
+  /**
+   * Extract affected files from a proposal
+   * @param {Proposal} proposal - Proposal to analyze
+   * @returns {Object[]} Affected files with operations
+   */
+  extractAffectedFiles(proposal) {
+    const files = [];
+    
+    for (const op of proposal.operations || []) {
+      if (op.path || op.file || op.filePath) {
+        files.push({
+          path: op.path || op.file || op.filePath,
+          operation: op.type || op.operation || "modify",
+        });
+      }
+    }
+    
+    return files;
+  }
+  
+  /**
+   * Calculate severity for file conflicts
+   * @param {Object} fileA - First file info
+   * @param {Object} fileB - Second file info
+   * @returns {string} Severity level
+   */
+  calculateFileSeverity(fileA, fileB) {
+    // Both deleting = critical
+    if (fileA.operation === "delete" && fileB.operation === "delete") {
+      return CONFLICT_SEVERITY.LOW; // Actually fine, same result
+    }
+    
+    // One deleting, one modifying = critical
+    if (fileA.operation === "delete" || fileB.operation === "delete") {
+      return CONFLICT_SEVERITY.CRITICAL;
+    }
+    
+    // Both creating = critical
+    if (fileA.operation === "create" && fileB.operation === "create") {
+      return CONFLICT_SEVERITY.CRITICAL;
+    }
+    
+    // Both modifying = high
+    return CONFLICT_SEVERITY.HIGH;
+  }
+  
+  /**
+   * Check if an operation invalidates an assumption
+   * @param {Object} operation - Operation to check
+   * @param {Object} assumption - Assumption to validate against
+   * @returns {boolean} Does operation invalidate assumption
+   */
+  operationInvalidatesAssumption(operation, assumption) {
+    const opPath = this.normalizeTarget(operation.path || operation.file);
+    const assumptionTarget = this.normalizeTarget(assumption.target || assumption.path);
+    
+    // File deletion invalidates file_exists assumption
+    if (operation.type === "delete" && assumption.type === "file_exists" && opPath === assumptionTarget) {
+      return true;
+    }
+    
+    // File modification might invalidate content assumptions
+    if (operation.type === "modify" && assumption.type === "file_contains" && opPath === assumptionTarget) {
+      return true;
+    }
+    
+    // Route changes
+    if (assumption.type === "route_exists" && operation.type === "delete") {
+      // Check if deleting a route handler file
+      if (opPath.includes("routes") || opPath.includes("api")) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  /**
+   * Check if two operations are incompatible
+   * @param {Object} opA - First operation
+   * @param {Object} opB - Second operation
+   * @returns {boolean} Are operations incompatible
+   */
+  operationsIncompatible(opA, opB) {
+    const pathA = this.normalizeTarget(opA.path || opA.file);
+    const pathB = this.normalizeTarget(opB.path || opB.file);
+    
+    if (pathA !== pathB) return false;
+    
+    // Create + Create = incompatible (which one wins?)
+    if (opA.type === "create" && opB.type === "create") {
+      return true;
+    }
+    
+    // Delete + Modify = incompatible
+    if ((opA.type === "delete" && opB.type === "modify") ||
+        (opA.type === "modify" && opB.type === "delete")) {
+      return true;
+    }
+    
+    // Delete + Create might be rename - allow
+    // Modify + Modify might be mergeable - allow (handle at merge time)
+    
+    return false;
+  }
+  
+  /**
+   * Get reason for operation incompatibility
+   * @param {Object} opA - First operation
+   * @param {Object} opB - Second operation
+   * @returns {string} Reason description
+   */
+  getIncompatibilityReason(opA, opB) {
+    if (opA.type === "create" && opB.type === "create") {
+      return "Both agents trying to create the same file";
+    }
+    if (opA.type === "delete" && opB.type === "modify") {
+      return "One agent deleting while another modifies";
+    }
+    if (opA.type === "modify" && opB.type === "delete") {
+      return "One agent modifying while another deletes";
+    }
+    return "Operations cannot be applied together";
+  }
+  
+  /**
+   * Suggest resolution strategies for a conflict
+   * @param {string} conflictType - Type of conflict
+   * @param {Object} contextA - First context
+   * @param {Object} contextB - Second context
+   * @returns {string[]} Suggested strategies
+   */
+  suggestResolutions(conflictType, contextA, contextB) {
+    switch (conflictType) {
+      case CONFLICT_TYPES.SAME_FILE:
+        if (contextA.operation === "modify" && contextB.operation === "modify") {
+          return [RESOLUTION_STRATEGIES.MERGE, RESOLUTION_STRATEGIES.QUEUE];
+        }
+        return [RESOLUTION_STRATEGIES.QUEUE, RESOLUTION_STRATEGIES.REJECT];
+        
+      case CONFLICT_TYPES.DEPENDENT_ASSUMPTION:
+        return [RESOLUTION_STRATEGIES.QUEUE, RESOLUTION_STRATEGIES.REJECT];
+        
+      case CONFLICT_TYPES.INCOMPATIBLE_OPERATION:
+        return [RESOLUTION_STRATEGIES.REJECT, RESOLUTION_STRATEGIES.DEFER];
+        
+      default:
+        return [RESOLUTION_STRATEGIES.QUEUE];
+    }
+  }
+  
+  /**
+   * Get all conflicts for a proposal
+   * @param {string} proposalId - Proposal ID
+   * @returns {Conflict[]} Conflicts
+   */
+  getConflictsForProposal(proposalId) {
+    return this.conflicts.filter(
+      c => c.proposalA === proposalId || c.proposalB === proposalId
+    );
+  }
+  
+  /**
+   * Get all unresolved conflicts
+   * @returns {Conflict[]} Unresolved conflicts
+   */
+  getUnresolvedConflicts() {
+    return this.conflicts.filter(c => !this.resolutions.has(c.id));
+  }
+  
+  /**
+   * Resolve a conflict
+   * @param {string} conflictId - Conflict ID
+   * @param {string} strategy - Resolution strategy
+   * @param {Object} details - Resolution details
+   */
+  resolveConflict(conflictId, strategy, details = {}) {
+    this.resolutions.set(conflictId, {
+      strategy,
+      details,
+      resolvedAt: new Date(),
+    });
+  }
+  
+  /**
+   * Check if a proposal can proceed
+   * @param {string} proposalId - Proposal ID
+   * @returns {Object} Can proceed result
+   */
+  canProceed(proposalId) {
+    const conflicts = this.getConflictsForProposal(proposalId);
+    
+    if (conflicts.length === 0) {
+      return { canProceed: true, conflicts: [] };
+    }
+    
+    const unresolvedCritical = conflicts.filter(
+      c => !this.resolutions.has(c.id) && c.severity === CONFLICT_SEVERITY.CRITICAL
+    );
+    
+    const unresolvedHigh = conflicts.filter(
+      c => !this.resolutions.has(c.id) && c.severity === CONFLICT_SEVERITY.HIGH
+    );
+    
+    return {
+      canProceed: unresolvedCritical.length === 0,
+      mustResolve: unresolvedCritical,
+      shouldResolve: unresolvedHigh,
+      conflicts,
+    };
+  }
+  
+  /**
+   * Build the full conflict graph
+   * @returns {Object} Conflict graph representation
+   */
+  buildConflictGraph() {
+    const nodes = [];
+    const edges = [];
+    
+    for (const [proposalId, proposal] of this.proposals) {
+      nodes.push({
+        id: proposalId,
+        agentId: proposal.agentId,
+        sessionId: proposal.sessionId,
+        intent: proposal.intent,
+      });
+    }
+    
+    for (const conflict of this.conflicts) {
+      edges.push({
+        source: conflict.proposalA,
+        target: conflict.proposalB,
+        type: conflict.type,
+        severity: conflict.severity,
+        resolved: this.resolutions.has(conflict.id),
+      });
+    }
+    
+    return { nodes, edges };
+  }
+  
+  /**
+   * Clear all proposals and conflicts
+   */
+  clear() {
+    this.proposals.clear();
+    this.assumptionGraph.clear();
+    this.conflicts = [];
+    this.resolutions.clear();
+  }
+}
+
+/**
+ * Create a new conflict resolver
+ * @returns {ConflictResolver} New resolver
+ */
+function createConflictResolver() {
+  return new ConflictResolver();
+}
+
+export {
+  ConflictResolver,
+  createConflictResolver,
+  CONFLICT_TYPES,
+  CONFLICT_SEVERITY,
+  RESOLUTION_STRATEGIES,
+};