vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/status/AgentStatusManager.js

@@ -0,0 +1,481 @@
+/**
+ * Agent Status Manager
+ * 
+ * Manages agent status transitions and persistence.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { AgentStatus } = require('../AgentStatus');
+const { isValidTransition } = require('../AgentStatus');
+
+/**
+ * Agent status manager class
+ */
+class AgentStatusManager {
+  /**
+   * Create status manager instance
+   * @param {Object} config - Manager configuration
+   */
+  constructor(config = {}) {
+    this.configManager = config.configManager || null;
+    this.logger = config.logger || null;
+    this.fileManager = config.fileManager || null;
+    this.statusHistory = new Map(); // agentId -> array of status changes
+    this.maxHistorySize = config.maxHistorySize || 100;
+    this.autoSave = config.autoSave !== false; // Default to auto-save
+  }
+
+  /**
+   * Update agent status with validation
+   * @param {string} agentId - Agent identifier
+   * @param {string} newStatus - New status
+   * @param {string} message - Status message
+   * @returns {Promise<Object>} - Status update result
+   */
+  async updateAgentStatus(agentId, newStatus, message = '') {
+    try {
+      // Get current status
+      const currentStatus = await this.getCurrentStatus(agentId);
+      
+      // Validate transition
+      if (currentStatus && !isValidTransition(currentStatus, newStatus)) {
+        const error = new Error(`Invalid status transition: ${currentStatus} -> ${newStatus}`);
+        
+        if (this.logger) {
+          await this.logger.warn('Invalid status transition attempted', {
+            agentId,
+            currentStatus,
+            newStatus,
+            message: error.message
+          });
+        }
+        
+        throw error;
+      }
+
+      // Create status change record
+      const statusChange = {
+        agentId,
+        oldStatus: currentStatus,
+        newStatus,
+        message,
+        timestamp: new Date().toISOString(),
+        source: 'status_manager'
+      };
+
+      // Add to history
+      this.addToHistory(agentId, statusChange);
+      
+      // Update persistent storage
+      if (this.configManager) {
+        await this.configManager.updateAgentStatus(agentId, newStatus, message);
+      }
+
+      // Log status change
+      await this.logStatusChange(statusChange);
+      
+      return {
+        success: true,
+        agentId,
+        oldStatus: currentStatus,
+        newStatus,
+        message,
+        timestamp: statusChange.timestamp
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Status update failed', {
+          agentId,
+          newStatus,
+          error: error.message
+        });
+      }
+      
+      return {
+        success: false,
+        agentId,
+        newStatus,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Get current agent status
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<string|null>} - Current status
+   */
+  async getCurrentStatus(agentId) {
+    try {
+      if (this.configManager) {
+        const status = await this.configManager.getAgentStatus(agentId);
+        return status ? status.status : null;
+      }
+      return null;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to get current status', {
+          agentId,
+          error: error.message
+        });
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Get agent status history
+   * @param {string} agentId - Agent identifier
+   * @param {number} limit - Maximum number of entries to return
+   * @returns {Array<Object>} - Status history
+   */
+  getStatusHistory(agentId, limit = 50) {
+    const history = this.statusHistory.get(agentId) || [];
+    return history.slice(-limit); // Return most recent entries
+  }
+
+  /**
+   * Get status history for all agents
+   * @param {number} limit - Maximum entries per agent
+   * @returns {Object} - All agents' history
+   */
+  getAllStatusHistory(limit = 50) {
+    const allHistory = {};
+    
+    for (const [agentId, history] of this.statusHistory) {
+      allHistory[agentId] = history.slice(-limit);
+    }
+    
+    return allHistory;
+  }
+
+  /**
+   * Add status change to history
+   * @param {string} agentId - Agent identifier
+   * @param {Object} statusChange - Status change record
+   */
+  addToHistory(agentId, statusChange) {
+    if (!this.statusHistory.has(agentId)) {
+      this.statusHistory.set(agentId, []);
+    }
+    
+    const history = this.statusHistory.get(agentId);
+    history.push(statusChange);
+    
+    // Limit history size
+    if (history.length > this.maxHistorySize) {
+      this.statusHistory.set(agentId, history.slice(-this.maxHistorySize));
+    }
+    
+    // Auto-save if enabled
+    if (this.autoSave) {
+      this.saveHistoryToStorage(agentId);
+    }
+  }
+
+  /**
+   * Save status history to persistent storage
+   * @param {string} agentId - Agent identifier
+   */
+  async saveHistoryToStorage(agentId) {
+    if (!this.fileManager) {
+      return;
+    }
+
+    try {
+      const history = this.getStatusHistory(agentId);
+      const historyData = {
+        agentId,
+        history,
+        lastUpdated: new Date().toISOString()
+      };
+      
+      await this.fileManager.writeLog('status-history', historyData);
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to save status history', {
+          agentId,
+          error: error.message
+        });
+      }
+    }
+  }
+
+  /**
+   * Log status change
+   * @param {Object} statusChange - Status change record
+   */
+  async logStatusChange(statusChange) {
+    if (this.fileManager) {
+      await this.fileManager.writeLog('status-change', {
+        agentId: statusChange.agentId,
+        oldStatus: statusChange.oldStatus,
+        newStatus: statusChange.newStatus,
+        message: statusChange.message,
+        timestamp: statusChange.timestamp,
+        source: statusChange.source
+      });
+    }
+  }
+
+  /**
+   * Get agents by status
+   * @param {string} status - Status to filter by
+   * @param {Array<string>} agentIds - Specific agent IDs to check (optional)
+   * @returns {Promise<Object>} - Agents with specified status
+   */
+  async getAgentsByStatus(status, agentIds = null) {
+    try {
+      const agents = agentIds 
+        ? await this.getSpecificAgents(agentIds)
+        : await this.configManager.getAllAgents();
+      
+      const filteredAgents = agents.filter(agent => {
+        const agentStatus = agent.status || AgentStatus.NOT_INSTALLED;
+        return agentStatus === status;
+      });
+      
+      return {
+        status,
+        agents: filteredAgents,
+        count: filteredAgents.length
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to get agents by status', {
+          status,
+          agentIds,
+          error: error.message
+        });
+      }
+      
+      return {
+        status,
+        agents: [],
+        count: 0,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get specific agents by IDs
+   * @param {Array<string>} agentIds - Agent IDs
+   * @returns {Promise<Array>} - Agent objects
+   */
+  async getSpecificAgents(agentIds) {
+    const agents = [];
+    
+    for (const agentId of agentIds) {
+      const agent = this.configManager.getAgent(agentId);
+      if (agent) {
+        agents.push(agent);
+      }
+    }
+    
+    return agents;
+  }
+
+  /**
+   * Get status statistics
+   * @param {Array<string>} agentIds - Specific agent IDs (optional)
+   * @returns {Promise<Object>} - Status statistics
+   */
+  async getStatusStatistics(agentIds = null) {
+    try {
+      const agents = agentIds 
+        ? await this.getSpecificAgents(agentIds)
+        : await this.configManager.getAllAgents();
+      
+      const stats = {
+        totalAgents: agents.length,
+        notInstalled: 0,
+        installing: 0,
+        installed: 0,
+        verifying: 0,
+        verified: 0,
+        error: 0,
+        rateLimited: 0,
+        disabled: 0,
+        lastUpdated: null
+      };
+
+      let latestUpdate = null;
+      
+      for (const agent of agents) {
+        const status = agent.status || AgentStatus.NOT_INSTALLED;
+        
+        switch (status) {
+          case AgentStatus.NOT_INSTALLED:
+            stats.notInstalled++;
+            break;
+          case AgentStatus.INSTALLING:
+            stats.installing++;
+            break;
+          case AgentStatus.INSTALLED:
+            stats.installed++;
+            break;
+          case AgentStatus.VERIFYING:
+            stats.verifying++;
+            break;
+          case AgentStatus.VERIFIED:
+            stats.verified++;
+            break;
+          case AgentStatus.ERROR:
+            stats.error++;
+            break;
+          case AgentStatus.RATE_LIMITED:
+            stats.rateLimited++;
+            break;
+          case AgentStatus.DISABLED:
+            stats.disabled++;
+            break;
+        }
+        
+        // Track latest update
+        if (agent.lastChecked) {
+          const updateDate = new Date(agent.lastChecked);
+          if (!latestUpdate || updateDate > latestUpdate) {
+            latestUpdate = agent.lastChecked;
+          }
+        }
+      }
+      
+      stats.lastUpdated = latestUpdate ? latestUpdate.toISOString() : null;
+      
+      return stats;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to get status statistics', {
+          agentIds,
+          error: error.message
+        });
+      }
+      
+      return {
+        totalAgents: 0,
+        notInstalled: 0,
+        installing: 0,
+        installed: 0,
+        verifying: 0,
+        verified: 0,
+        error: 0,
+        rateLimited: 0,
+        disabled: 0,
+        lastUpdated: null,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Reset agent status
+   * @param {string} agentId - Agent identifier
+   * @param {string} message - Reset message
+   * @returns {Promise<Object>} - Reset result
+   */
+  async resetAgentStatus(agentId, message = 'Status reset') {
+    try {
+      // Clear history
+      this.statusHistory.delete(agentId);
+      
+      // Reset to NOT_INSTALLED status
+      return await this.updateAgentStatus(agentId, AgentStatus.NOT_INSTALLED, message);
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to reset agent status', {
+          agentId,
+          error: error.message
+        });
+      }
+      
+      return {
+        success: false,
+        agentId,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Bulk update agent statuses
+   * @param {Array<Object>} updates - Array of status updates
+   * @returns {Promise<Object>} - Bulk update result
+   */
+  async bulkUpdateStatuses(updates) {
+    const results = {
+      totalUpdates: updates.length,
+      successful: 0,
+      failed: 0,
+      results: {}
+    };
+
+    for (const update of updates) {
+      try {
+        const result = await this.updateAgentStatus(update.agentId, update.newStatus, update.message);
+        results.results[update.agentId] = result;
+        
+        if (result.success) {
+          results.successful++;
+        } else {
+          results.failed++;
+        }
+      } catch (error) {
+        results.results[update.agentId] = {
+          success: false,
+          agentId: update.agentId,
+          error: error.message,
+          timestamp: new Date().toISOString()
+        };
+        results.failed++;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get status manager information
+   * @returns {Object} - Manager info
+   */
+  getManagerInfo() {
+    return {
+      maxHistorySize: this.maxHistorySize,
+      autoSave: this.autoSave,
+      trackedAgents: this.statusHistory.size,
+      totalHistoryEntries: Array.from(this.statusHistory.values())
+        .reduce((total, history) => total + history.length, 0),
+      supportedStatuses: Object.values(AgentStatus),
+      features: [
+        'status transition validation',
+        'status history tracking',
+        'bulk status updates',
+        'status statistics',
+        'persistent storage',
+        'logging integration'
+      ],
+      limitations: [
+        'depends on config manager',
+        'memory usage with large history',
+        'storage dependency'
+      ]
+    };
+  }
+
+  /**
+   * Create status manager with default configuration
+   * @param {Object} config - Configuration overrides
+   * @returns {AgentStatusManager} - Manager instance
+   */
+  static createDefault(config = {}) {
+    return new AgentStatusManager({
+      maxHistorySize: 100,
+      autoSave: true,
+      ...config
+    });
+  }
+}
+
+module.exports = AgentStatusManager;