@vibecheckai/cli 3.2.5 → 3.3.0

package/mcp-server/conductor/request-queue.js

@@ -0,0 +1,550 @@
+/**
+ * Conductor Request Queue
+ * 
+ * Priority queue for multi-agent request processing.
+ * Implements tier-based ordering with fair scheduling.
+ * 
+ * Codename: Conductor
+ */
+
+"use strict";
+
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { conductorLogger as log, getErrorMessage } from "../logger.js";
+
+/**
+ * Request priority based on tier
+ */
+const TIER_PRIORITY = {
+  ENTERPRISE: 100,
+  PRO: 75,
+  STARTER: 50,
+  FREE: 25,
+};
+
+/**
+ * Request states
+ */
+const REQUEST_STATE = {
+  PENDING: "pending",
+  PROCESSING: "processing",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+};
+
+/**
+ * @typedef {Object} QueuedRequest
+ * @property {string} requestId - Unique request ID
+ * @property {string} proposalId - Associated proposal ID
+ * @property {string} sessionId - Session ID
+ * @property {string} agentId - Agent ID
+ * @property {string} tier - User tier
+ * @property {number} priority - Calculated priority
+ * @property {Date} queuedAt - When request was queued
+ * @property {Date} processedAt - When processing started
+ * @property {string} state - Current state
+ * @property {number} attempts - Number of processing attempts
+ * @property {Object} payload - Request payload
+ */
+
+/**
+ * Request Queue class
+ */
+class RequestQueue {
+  constructor(options = {}) {
+    this.queue = []; // Sorted by priority
+    this.processing = new Map(); // requestId -> QueuedRequest
+    this.completed = new Map(); // requestId -> QueuedRequest (recent)
+    this.maxConcurrent = options.maxConcurrent || 5;
+    this.maxRetries = options.maxRetries || 3;
+    this.fairSchedulingWindow = options.fairSchedulingWindow || 10000; // 10 seconds
+    this.persistPath = options.persistPath || null;
+    
+    // Track requests per tier for fair scheduling
+    this.tierRequestCounts = {
+      ENTERPRISE: { queued: 0, processed: 0 },
+      PRO: { queued: 0, processed: 0 },
+      STARTER: { queued: 0, processed: 0 },
+      FREE: { queued: 0, processed: 0 },
+    };
+    
+    // Load persisted state
+    if (this.persistPath) {
+      this.loadState();
+    }
+  }
+  
+  /**
+   * Generate a unique request ID
+   * @returns {string} Request ID
+   */
+  generateRequestId() {
+    return `req_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+  }
+  
+  /**
+   * Calculate priority for a request
+   * @param {string} tier - User tier
+   * @param {Date} queuedAt - When queued
+   * @returns {number} Priority score
+   */
+  calculatePriority(tier, queuedAt) {
+    const basePriority = TIER_PRIORITY[tier] || 25;
+    
+    // Add time-based bonus (older requests get slight boost)
+    const ageSeconds = (Date.now() - queuedAt.getTime()) / 1000;
+    const ageBonus = Math.min(ageSeconds / 60, 10); // Max 10 points after 10 minutes
+    
+    // Fair scheduling adjustment
+    const tierStats = this.tierRequestCounts[tier] || { queued: 0, processed: 0 };
+    const fairnessBonus = tierStats.queued > tierStats.processed ? 5 : 0;
+    
+    return basePriority + ageBonus + fairnessBonus;
+  }
+  
+  /**
+   * Enqueue a request
+   * @param {Object} params - Request parameters
+   * @returns {QueuedRequest} Queued request
+   */
+  enqueue({
+    proposalId,
+    sessionId,
+    agentId,
+    tier = "FREE",
+    payload = {},
+  }) {
+    const requestId = this.generateRequestId();
+    const queuedAt = new Date();
+    
+    const request = {
+      requestId,
+      proposalId,
+      sessionId,
+      agentId,
+      tier,
+      priority: this.calculatePriority(tier, queuedAt),
+      queuedAt,
+      processedAt: null,
+      completedAt: null,
+      state: REQUEST_STATE.PENDING,
+      attempts: 0,
+      payload,
+    };
+    
+    // Insert in priority order
+    this.insertByPriority(request);
+    
+    // Update tier counts
+    if (this.tierRequestCounts[tier]) {
+      this.tierRequestCounts[tier].queued++;
+    }
+    
+    this.saveState();
+    
+    return request;
+  }
+  
+  /**
+   * Insert a request in priority order
+   * @param {QueuedRequest} request - Request to insert
+   */
+  insertByPriority(request) {
+    // Find insertion point
+    let insertIndex = this.queue.length;
+    
+    for (let i = 0; i < this.queue.length; i++) {
+      if (request.priority > this.queue[i].priority) {
+        insertIndex = i;
+        break;
+      }
+    }
+    
+    this.queue.splice(insertIndex, 0, request);
+  }
+  
+  /**
+   * Dequeue the next request for processing
+   * @returns {QueuedRequest|null} Next request or null
+   */
+  dequeue() {
+    // Check if we can process more
+    if (this.processing.size >= this.maxConcurrent) {
+      return null;
+    }
+    
+    // Find next request that isn't blocked
+    for (let i = 0; i < this.queue.length; i++) {
+      const request = this.queue[i];
+      
+      // Update priority (in case it changed due to aging)
+      request.priority = this.calculatePriority(request.tier, new Date(request.queuedAt));
+      
+      // For now, just take the first one
+      this.queue.splice(i, 1);
+      
+      // Move to processing
+      request.state = REQUEST_STATE.PROCESSING;
+      request.processedAt = new Date();
+      request.attempts++;
+      
+      this.processing.set(request.requestId, request);
+      
+      this.saveState();
+      
+      return request;
+    }
+    
+    return null;
+  }
+  
+  /**
+   * Mark a request as completed
+   * @param {string} requestId - Request ID
+   * @param {Object} result - Processing result
+   * @returns {boolean} Success
+   */
+  complete(requestId, result = {}) {
+    const request = this.processing.get(requestId);
+    if (!request) return false;
+    
+    request.state = REQUEST_STATE.COMPLETED;
+    request.completedAt = new Date();
+    request.result = result;
+    
+    // Move from processing to completed
+    this.processing.delete(requestId);
+    this.completed.set(requestId, request);
+    
+    // Update tier counts
+    if (this.tierRequestCounts[request.tier]) {
+      this.tierRequestCounts[request.tier].processed++;
+    }
+    
+    // Cleanup old completed requests
+    this.cleanupCompleted();
+    
+    this.saveState();
+    
+    return true;
+  }
+  
+  /**
+   * Mark a request as failed
+   * @param {string} requestId - Request ID
+   * @param {Error|string} error - Error information
+   * @returns {boolean} Success or requeued
+   */
+  fail(requestId, error) {
+    const request = this.processing.get(requestId);
+    if (!request) return false;
+    
+    this.processing.delete(requestId);
+    
+    // Check if we should retry
+    if (request.attempts < this.maxRetries) {
+      // Requeue with lower priority
+      request.state = REQUEST_STATE.PENDING;
+      request.priority = Math.max(1, request.priority - 10);
+      request.lastError = error?.message || String(error);
+      
+      this.insertByPriority(request);
+      
+      this.saveState();
+      return true; // Requeued
+    }
+    
+    // Max retries exceeded
+    request.state = REQUEST_STATE.FAILED;
+    request.completedAt = new Date();
+    request.error = error?.message || String(error);
+    
+    this.completed.set(requestId, request);
+    
+    this.saveState();
+    
+    return false;
+  }
+  
+  /**
+   * Cancel a request
+   * @param {string} requestId - Request ID
+   * @returns {boolean} Success
+   */
+  cancel(requestId) {
+    // Check queue
+    const queueIndex = this.queue.findIndex(r => r.requestId === requestId);
+    if (queueIndex !== -1) {
+      const request = this.queue.splice(queueIndex, 1)[0];
+      request.state = REQUEST_STATE.CANCELLED;
+      request.completedAt = new Date();
+      this.completed.set(requestId, request);
+      this.saveState();
+      return true;
+    }
+    
+    // Check processing
+    const processing = this.processing.get(requestId);
+    if (processing) {
+      processing.state = REQUEST_STATE.CANCELLED;
+      processing.completedAt = new Date();
+      this.processing.delete(requestId);
+      this.completed.set(requestId, processing);
+      this.saveState();
+      return true;
+    }
+    
+    return false;
+  }
+  
+  /**
+   * Cancel all requests for a session
+   * @param {string} sessionId - Session ID
+   * @returns {number} Number cancelled
+   */
+  cancelSession(sessionId) {
+    let cancelled = 0;
+    
+    // Cancel from queue
+    for (let i = this.queue.length - 1; i >= 0; i--) {
+      if (this.queue[i].sessionId === sessionId) {
+        this.cancel(this.queue[i].requestId);
+        cancelled++;
+      }
+    }
+    
+    // Cancel from processing
+    for (const [requestId, request] of this.processing) {
+      if (request.sessionId === sessionId) {
+        this.cancel(requestId);
+        cancelled++;
+      }
+    }
+    
+    return cancelled;
+  }
+  
+  /**
+   * Get a request by ID
+   * @param {string} requestId - Request ID
+   * @returns {QueuedRequest|null} Request or null
+   */
+  getRequest(requestId) {
+    // Check queue
+    const queued = this.queue.find(r => r.requestId === requestId);
+    if (queued) return queued;
+    
+    // Check processing
+    const processing = this.processing.get(requestId);
+    if (processing) return processing;
+    
+    // Check completed
+    const completed = this.completed.get(requestId);
+    if (completed) return completed;
+    
+    return null;
+  }
+  
+  /**
+   * Get queue statistics
+   * @returns {Object} Statistics
+   */
+  getStatistics() {
+    const queueByTier = { FREE: 0, STARTER: 0, PRO: 0, ENTERPRISE: 0 };
+    const processingByTier = { FREE: 0, STARTER: 0, PRO: 0, ENTERPRISE: 0 };
+    
+    for (const request of this.queue) {
+      queueByTier[request.tier] = (queueByTier[request.tier] || 0) + 1;
+    }
+    
+    for (const request of this.processing.values()) {
+      processingByTier[request.tier] = (processingByTier[request.tier] || 0) + 1;
+    }
+    
+    return {
+      queueLength: this.queue.length,
+      processing: this.processing.size,
+      completed: this.completed.size,
+      maxConcurrent: this.maxConcurrent,
+      byTier: {
+        queue: queueByTier,
+        processing: processingByTier,
+        counts: this.tierRequestCounts,
+      },
+    };
+  }
+  
+  /**
+   * Get the current queue
+   * @param {Object} options - Filter options
+   * @returns {QueuedRequest[]} Queue items
+   */
+  getQueue(options = {}) {
+    let result = [...this.queue];
+    
+    if (options.tier) {
+      result = result.filter(r => r.tier === options.tier);
+    }
+    
+    if (options.sessionId) {
+      result = result.filter(r => r.sessionId === options.sessionId);
+    }
+    
+    if (options.limit) {
+      result = result.slice(0, options.limit);
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Get currently processing requests
+   * @returns {QueuedRequest[]} Processing requests
+   */
+  getProcessing() {
+    return Array.from(this.processing.values());
+  }
+  
+  /**
+   * Cleanup old completed requests
+   * @param {number} maxAge - Max age in milliseconds (default 1 hour)
+   */
+  cleanupCompleted(maxAge = 3600000) {
+    const cutoff = Date.now() - maxAge;
+    
+    for (const [requestId, request] of this.completed) {
+      if (new Date(request.completedAt).getTime() < cutoff) {
+        this.completed.delete(requestId);
+      }
+    }
+  }
+  
+  /**
+   * Resort the queue (useful after bulk operations)
+   */
+  resort() {
+    // Update all priorities
+    for (const request of this.queue) {
+      request.priority = this.calculatePriority(request.tier, new Date(request.queuedAt));
+    }
+    
+    // Sort by priority (descending)
+    this.queue.sort((a, b) => b.priority - a.priority);
+  }
+  
+  /**
+   * Save state to disk
+   */
+  saveState() {
+    if (!this.persistPath) return;
+    
+    try {
+      const dir = path.dirname(this.persistPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      const state = {
+        queue: this.queue,
+        processing: Array.from(this.processing.entries()),
+        tierRequestCounts: this.tierRequestCounts,
+        timestamp: new Date().toISOString(),
+      };
+      
+      fs.writeFileSync(this.persistPath, JSON.stringify(state, null, 2));
+    } catch (error) {
+      log.warn(`Failed to save queue state: ${getErrorMessage(error)}`);
+    }
+  }
+  
+  /**
+   * Load state from disk
+   */
+  loadState() {
+    if (!this.persistPath || !fs.existsSync(this.persistPath)) return;
+    
+    try {
+      const content = fs.readFileSync(this.persistPath, "utf-8");
+      const state = JSON.parse(content);
+      
+      // Restore queue
+      this.queue = (state.queue || []).map(r => ({
+        ...r,
+        queuedAt: new Date(r.queuedAt),
+        processedAt: r.processedAt ? new Date(r.processedAt) : null,
+      }));
+      
+      // Restore processing (mark as failed since we restarted)
+      for (const [requestId, request] of state.processing || []) {
+        request.queuedAt = new Date(request.queuedAt);
+        request.processedAt = new Date(request.processedAt);
+        
+        // Requeue interrupted processing
+        request.state = REQUEST_STATE.PENDING;
+        request.priority = Math.max(1, request.priority - 5);
+        this.insertByPriority(request);
+      }
+      
+      // Restore tier counts
+      this.tierRequestCounts = state.tierRequestCounts || this.tierRequestCounts;
+      
+      log.info(`Restored queue with ${this.queue.length} pending requests`);
+    } catch (error) {
+      log.warn(`Failed to load queue state: ${getErrorMessage(error)}`);
+    }
+  }
+  
+  /**
+   * Clear the queue
+   */
+  clear() {
+    this.queue = [];
+    this.processing.clear();
+    this.completed.clear();
+    this.tierRequestCounts = {
+      ENTERPRISE: { queued: 0, processed: 0 },
+      PRO: { queued: 0, processed: 0 },
+      STARTER: { queued: 0, processed: 0 },
+      FREE: { queued: 0, processed: 0 },
+    };
+    this.saveState();
+  }
+}
+
+/**
+ * Create a new request queue
+ * @param {Object} options - Queue options
+ * @returns {RequestQueue} New queue
+ */
+function createRequestQueue(options = {}) {
+  return new RequestQueue(options);
+}
+
+// Default instance
+let defaultQueue = null;
+
+/**
+ * Get the default request queue
+ * @param {string} projectRoot - Project root for persist path
+ * @returns {RequestQueue} Default queue
+ */
+function getRequestQueue(projectRoot) {
+  if (!defaultQueue) {
+    const persistPath = projectRoot
+      ? path.join(projectRoot, ".vibecheck", "conductor", "queue.json")
+      : null;
+    defaultQueue = createRequestQueue({ persistPath });
+  }
+  return defaultQueue;
+}
+
+export {
+  RequestQueue,
+  createRequestQueue,
+  getRequestQueue,
+  TIER_PRIORITY,
+  REQUEST_STATE,
+};