@vibecheckai/cli 3.9.1 → 4.0.0

package/mcp-server/conductor/index.js

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