@vibecheckai/cli 3.5.1 → 3.5.2

package/mcp-server/conductor/index.js

@@ -0,0 +1,377 @@
+/**
+ * Conductor Module
+ * 
+ * Multi-Agent Coordination Firewall
+ * Prevents conflicts when multiple AI agents modify the codebase.
+ * 
+ * Codename: Conductor
+ */
+
+"use strict";
+
+import {
+  SessionManager,
+  createSessionManager,
+  getSessionManager,
+  TIER_TRUST_MAP,
+  DEFAULT_SESSION_TIMEOUT_MS,
+} from "./session-manager.js";
+
+import {
+  LockManager,
+  createLockManager,
+  getLockManager,
+  LOCK_TYPES,
+  DEFAULT_LOCK_TIMEOUT_MS,
+} from "./lock-manager.js";
+
+import {
+  ConflictResolver,
+  createConflictResolver,
+  CONFLICT_TYPES,
+  CONFLICT_SEVERITY,
+  RESOLUTION_STRATEGIES,
+} from "./conflict-resolver.js";
+
+import {
+  ExecutionPlanner,
+  createExecutionPlanner,
+  TIER_PRIORITY,
+} from "./execution-planner.js";
+
+import {
+  RequestQueue,
+  createRequestQueue,
+  getRequestQueue,
+  REQUEST_STATE,
+} from "./request-queue.js";
+
+/**
+ * Conductor singleton that provides coordinated access to session and lock managers
+ */
+class Conductor {
+  constructor() {
+    this.sessionManager = null;
+    this.lockManager = null;
+    this.conflictResolver = null;
+    this.executionPlanner = null;
+    this.requestQueue = null;
+    this.initialized = false;
+  }
+  
+  /**
+   * Initialize the Conductor for a project
+   * @param {string} projectRoot - Project root directory
+   * @returns {Conductor} This instance
+   */
+  init(projectRoot) {
+    if (this.initialized) {
+      return this;
+    }
+    
+    this.sessionManager = getSessionManager(projectRoot);
+    this.lockManager = getLockManager(projectRoot);
+    this.conflictResolver = createConflictResolver();
+    this.executionPlanner = createExecutionPlanner(this.conflictResolver);
+    this.requestQueue = getRequestQueue(projectRoot);
+    this.initialized = true;
+    
+    return this;
+  }
+  
+  /**
+   * Register an agent session
+   * @param {Object} params - Registration params
+   * @returns {Object} Session info
+   */
+  registerAgent({ agentId, tier, projectRoot, workingFiles = [] }) {
+    this.ensureInitialized(projectRoot);
+    
+    return this.sessionManager.registerSession({
+      agentId,
+      tier,
+      projectRoot,
+      workingFiles,
+    });
+  }
+  
+  /**
+   * Acquire a lock for a session
+   * @param {Object} params - Lock params
+   * @returns {Object} Lock result
+   */
+  acquireLock({ sessionId, path, type = "exclusive", reason = "" }) {
+    this.ensureInitialized();
+    
+    const session = this.sessionManager.getSession(sessionId);
+    if (!session) {
+      return {
+        acquired: false,
+        error: "Invalid or expired session",
+      };
+    }
+    
+    return this.lockManager.acquireLock({
+      path,
+      type,
+      sessionId,
+      agentId: session.agentId,
+      reason,
+    });
+  }
+  
+  /**
+   * Release a lock
+   * @param {string} lockId - Lock ID
+   * @param {string} sessionId - Session ID
+   * @returns {boolean} Success
+   */
+  releaseLock(lockId, sessionId) {
+    this.ensureInitialized();
+    
+    return this.lockManager.releaseLock(lockId, sessionId);
+  }
+  
+  /**
+   * Check if a path is locked by another session
+   * @param {string} path - Path to check
+   * @param {string} sessionId - Current session ID
+   * @returns {Object} Lock status
+   */
+  checkLockStatus(path, sessionId) {
+    this.ensureInitialized();
+    
+    const conflicts = this.lockManager.getConflictingLocks(path, LOCK_TYPES.EXCLUSIVE);
+    const otherLocks = conflicts.filter(l => l.sessionId !== sessionId);
+    
+    return {
+      locked: otherLocks.length > 0,
+      ownLock: conflicts.find(l => l.sessionId === sessionId) || null,
+      blockedBy: otherLocks,
+    };
+  }
+  
+  /**
+   * Get the status of multi-agent coordination
+   * @param {string} projectRoot - Project root
+   * @returns {Object} Coordination status
+   */
+  getStatus(projectRoot) {
+    this.ensureInitialized(projectRoot);
+    
+    return {
+      sessions: this.sessionManager.getStatistics(),
+      locks: this.lockManager.getStatistics(),
+      activeAgents: this.sessionManager.getActiveAgents(projectRoot),
+      deadlocks: this.lockManager.detectDeadlocks(),
+      queue: this.requestQueue.getStatistics(),
+      conflicts: this.conflictResolver.getUnresolvedConflicts().length,
+    };
+  }
+  
+  /**
+   * Submit a proposal for coordination
+   * @param {Object} proposal - Proposal to submit
+   * @returns {Object} Submission result
+   */
+  submitProposal(proposal) {
+    this.ensureInitialized();
+    
+    // Add to conflict resolver
+    this.conflictResolver.addProposal(proposal);
+    
+    // Check for conflicts
+    const canProceed = this.conflictResolver.canProceed(proposal.proposalId);
+    
+    if (!canProceed.canProceed) {
+      return {
+        accepted: false,
+        queued: false,
+        conflicts: canProceed.mustResolve,
+        warnings: canProceed.shouldResolve,
+      };
+    }
+    
+    // Queue for processing
+    const queuedRequest = this.requestQueue.enqueue({
+      proposalId: proposal.proposalId,
+      sessionId: proposal.sessionId,
+      agentId: proposal.agentId,
+      tier: proposal.tier || "FREE",
+      payload: proposal,
+    });
+    
+    return {
+      accepted: true,
+      queued: true,
+      requestId: queuedRequest.requestId,
+      position: this.requestQueue.queue.findIndex(r => r.requestId === queuedRequest.requestId) + 1,
+      conflicts: [],
+      warnings: canProceed.shouldResolve || [],
+    };
+  }
+  
+  /**
+   * Create an execution plan for pending proposals
+   * @param {string} projectRoot - Project root
+   * @returns {Object} Execution plan
+   */
+  createExecutionPlan(projectRoot) {
+    this.ensureInitialized(projectRoot);
+    
+    // Get all pending proposals from queue
+    const pendingRequests = this.requestQueue.getQueue();
+    const proposals = pendingRequests.map(r => r.payload);
+    
+    if (proposals.length === 0) {
+      return {
+        planId: null,
+        steps: [],
+        canExecute: true,
+        message: "No pending proposals",
+      };
+    }
+    
+    return this.executionPlanner.createPlan(proposals);
+  }
+  
+  /**
+   * Get the next request to process
+   * @returns {Object|null} Next request or null
+   */
+  getNextRequest() {
+    this.ensureInitialized();
+    return this.requestQueue.dequeue();
+  }
+  
+  /**
+   * Complete a request
+   * @param {string} requestId - Request ID
+   * @param {Object} result - Result
+   * @returns {boolean} Success
+   */
+  completeRequest(requestId, result = {}) {
+    this.ensureInitialized();
+    
+    const request = this.requestQueue.getRequest(requestId);
+    if (request) {
+      this.conflictResolver.removeProposal(request.proposalId);
+    }
+    
+    return this.requestQueue.complete(requestId, result);
+  }
+  
+  /**
+   * Fail a request
+   * @param {string} requestId - Request ID
+   * @param {Error|string} error - Error
+   * @returns {boolean} Success or requeued
+   */
+  failRequest(requestId, error) {
+    this.ensureInitialized();
+    return this.requestQueue.fail(requestId, error);
+  }
+  
+  /**
+   * Get conflicts for a proposal
+   * @param {string} proposalId - Proposal ID
+   * @returns {Object[]} Conflicts
+   */
+  getConflicts(proposalId) {
+    this.ensureInitialized();
+    return this.conflictResolver.getConflictsForProposal(proposalId);
+  }
+  
+  /**
+   * Resolve a conflict
+   * @param {string} conflictId - Conflict ID
+   * @param {string} strategy - Resolution strategy
+   * @param {Object} details - Resolution details
+   */
+  resolveConflict(conflictId, strategy, details = {}) {
+    this.ensureInitialized();
+    this.conflictResolver.resolveConflict(conflictId, strategy, details);
+  }
+  
+  /**
+   * Terminate a session and release all its locks
+   * @param {string} sessionId - Session ID
+   * @returns {Object} Termination result
+   */
+  terminateSession(sessionId) {
+    this.ensureInitialized();
+    
+    const locksReleased = this.lockManager.releaseSessionLocks(sessionId);
+    const sessionTerminated = this.sessionManager.terminateSession(sessionId);
+    
+    return {
+      sessionTerminated,
+      locksReleased,
+    };
+  }
+  
+  /**
+   * Ensure the conductor is initialized
+   * @param {string} projectRoot - Project root (optional, for lazy init)
+   */
+  ensureInitialized(projectRoot) {
+    if (!this.initialized && projectRoot) {
+      this.init(projectRoot);
+    }
+    
+    if (!this.initialized) {
+      throw new Error("Conductor not initialized. Call conductor.init(projectRoot) first.");
+    }
+  }
+  
+  /**
+   * Shutdown the conductor
+   */
+  shutdown() {
+    if (this.sessionManager) {
+      this.sessionManager.shutdown();
+    }
+    if (this.lockManager) {
+      this.lockManager.shutdown();
+    }
+    this.initialized = false;
+  }
+}
+
+// Singleton instance
+const conductor = new Conductor();
+
+export {
+  conductor,
+  Conductor,
+  // Session Manager
+  SessionManager,
+  createSessionManager,
+  getSessionManager,
+  // Lock Manager
+  LockManager,
+  createLockManager,
+  getLockManager,
+  LOCK_TYPES,
+  // Conflict Resolver
+  ConflictResolver,
+  createConflictResolver,
+  CONFLICT_TYPES,
+  CONFLICT_SEVERITY,
+  RESOLUTION_STRATEGIES,
+  // Execution Planner
+  ExecutionPlanner,
+  createExecutionPlanner,
+  TIER_PRIORITY,
+  // Request Queue
+  RequestQueue,
+  createRequestQueue,
+  getRequestQueue,
+  REQUEST_STATE,
+  // Constants
+  TIER_TRUST_MAP,
+  DEFAULT_SESSION_TIMEOUT_MS,
+  DEFAULT_LOCK_TIMEOUT_MS,
+};
+
+export default conductor;