@vibecheckai/cli 3.4.0 → 3.5.1

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

@@ -1,588 +0,0 @@
-/**
- * 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,
-};