vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/InstallationLog.js

@@ -0,0 +1,363 @@
+/**
+ * Installation Log Class
+ * 
+ * Represents a log entry for installation/verification operations.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { OperationType, OperationStatus } = require('./OperationTypes');
+
+/**
+ * Installation log class for tracking agent operations
+ */
+class InstallationLog {
+  /**
+   * Create a new InstallationLog instance
+   * @param {Object} config - Log configuration
+   * @param {string} config.id - Unique log identifier
+   * @param {string} config.agentId - Agent identifier
+   * @param {string} config.operation - Operation type
+   * @param {Date} config.timestamp - When the operation occurred
+   * @param {string} config.status - Operation status
+   * @param {string} config.message - Detailed log message
+   * @param {number} config.duration - Operation duration in milliseconds
+   * @param {string} config.errorDetails - Error information if failed
+   */
+  constructor(config = {}) {
+    this.id = config.id || this.generateId();
+    this.agentId = config.agentId || '';
+    this.operation = config.operation || '';
+    this.timestamp = config.timestamp || new Date();
+    this.status = config.status || '';
+    this.message = config.message || '';
+    this.duration = config.duration || 0;
+    this.errorDetails = config.errorDetails || '';
+    
+    this.validate();
+  }
+
+  /**
+   * Validate log configuration
+   * @throws {Error} If configuration is invalid
+   */
+  validate() {
+    if (!this.id || typeof this.id !== 'string') {
+      throw new Error('Installation log must have a valid non-empty string id');
+    }
+    
+    if (!this.agentId || typeof this.agentId !== 'string') {
+      throw new Error('Installation log must have a valid non-empty string agentId');
+    }
+    
+    if (!this.operation || typeof this.operation !== 'string') {
+      throw new Error('Installation log must have a valid non-empty string operation');
+    }
+    
+    if (!Object.values(OperationType).includes(this.operation)) {
+      throw new Error(`Invalid operation type: ${this.operation}`);
+    }
+    
+    if (!(this.timestamp instanceof Date) || isNaN(this.timestamp)) {
+      throw new Error('Timestamp must be a valid Date object');
+    }
+    
+    if (!this.status || typeof this.status !== 'string') {
+      throw new Error('Installation log must have a valid non-empty string status');
+    }
+    
+    if (!Object.values(OperationStatus).includes(this.status)) {
+      throw new Error(`Invalid operation status: ${this.status}`);
+    }
+    
+    if (!this.message || typeof this.message !== 'string') {
+      throw new Error('Installation log must have a valid non-empty string message');
+    }
+    
+    if (typeof this.duration !== 'number' || this.duration < 0) {
+      throw new Error('Duration must be a non-negative number');
+    }
+    
+    // Error details required if status is FAILED
+    if (this.status === OperationStatus.FAILED && !this.errorDetails) {
+      throw new Error('Error details are required when status is FAILED');
+    }
+  }
+
+  /**
+   * Generate unique log ID
+   * @returns {string} - Unique identifier
+   */
+  generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substr(2, 9);
+    return `log-${timestamp}-${random}`;
+  }
+
+  /**
+   * Update log status and message
+   * @param {string} newStatus - New operation status
+   * @param {string} message - Updated message
+   * @param {string} errorDetails - Error details if failed
+   * @param {number} additionalDuration - Additional duration to add
+   */
+  update(newStatus, message = '', errorDetails = '', additionalDuration = 0) {
+    const oldStatus = this.status;
+    this.status = newStatus;
+    this.message = message || this.message;
+    this.errorDetails = errorDetails || this.errorDetails;
+    this.duration += additionalDuration;
+    
+    return {
+      oldStatus,
+      newStatus,
+      timestamp: new Date()
+    };
+  }
+
+  /**
+   * Mark log as completed successfully
+   * @param {string} message - Completion message
+   * @param {number} finalDuration - Final duration if different
+   */
+  complete(message = '', finalDuration = null) {
+    if (finalDuration !== null) {
+      this.duration = finalDuration;
+    }
+    
+    return this.update(OperationStatus.COMPLETED, message);
+  }
+
+  /**
+   * Mark log as failed
+   * @param {string} error - Error message
+   * @param {string} errorDetails - Detailed error information
+   * @param {number} finalDuration - Final duration if different
+   */
+  fail(error, errorDetails = '', finalDuration = null) {
+    if (finalDuration !== null) {
+      this.duration = finalDuration;
+    }
+    
+    return this.update(OperationStatus.FAILED, error, errorDetails);
+  }
+
+  /**
+   * Mark log as timed out
+   * @param {number} timeoutDuration - Duration when timeout occurred
+   */
+  timeout(timeoutDuration = null) {
+    if (timeoutDuration !== null) {
+      this.duration = timeoutDuration;
+    }
+    
+    return this.update(OperationStatus.TIMEOUT, 'Operation timed out');
+  }
+
+  /**
+   * Check if log represents a successful operation
+   * @returns {boolean}
+   */
+  isSuccessful() {
+    return this.status === OperationStatus.COMPLETED;
+  }
+
+  /**
+   * Check if log represents a failed operation
+   * @returns {boolean}
+   */
+  isFailed() {
+    return this.status === OperationStatus.FAILED;
+  }
+
+  /**
+   * Check if log represents a timed out operation
+   * @returns {boolean}
+   */
+  isTimedOut() {
+    return this.status === OperationStatus.TIMEOUT;
+  }
+
+  /**
+   * Check if log represents an ongoing operation
+   * @returns {boolean}
+   */
+  isOngoing() {
+    return this.status === OperationStatus.STARTED;
+  }
+
+  /**
+   * Get human-readable status description
+   * @returns {string}
+   */
+  getStatusDescription() {
+    const descriptions = {
+      [OperationStatus.STARTED]: 'Started',
+      [OperationStatus.COMPLETED]: 'Completed',
+      [OperationStatus.FAILED]: 'Failed',
+      [OperationStatus.TIMEOUT]: 'Timed out',
+      [OperationStatus.CANCELLED]: 'Cancelled'
+    };
+
+    return descriptions[this.status] || 'Unknown';
+  }
+
+  /**
+   * Get formatted duration string
+   * @returns {string} - Formatted duration (e.g., "2.5s", "1m 30s")
+   */
+  getFormattedDuration() {
+    const duration = this.duration;
+    
+    if (duration < 1000) {
+      return `${duration}ms`;
+    }
+    
+    if (duration < 60000) {
+      return `${(duration / 1000).toFixed(1)}s`;
+    }
+    
+    const minutes = Math.floor(duration / 60000);
+    const seconds = ((duration % 60000) / 1000).toFixed(0);
+    return `${minutes}m ${seconds}s`;
+  }
+
+  /**
+   * Get formatted timestamp
+   * @returns {string} - ISO timestamp
+   */
+  getFormattedTimestamp() {
+    return this.timestamp.toISOString();
+  }
+
+  /**
+   * Check if log entry is recent (within last hour)
+   * @returns {boolean}
+   */
+  isRecent() {
+    const oneHour = 60 * 60 * 1000;
+    return (Date.now() - this.timestamp.getTime()) < oneHour;
+  }
+
+  /**
+   * Create a summary of the log entry
+   * @returns {Object} - Log summary
+   */
+  getSummary() {
+    return {
+      id: this.id,
+      agentId: this.agentId,
+      operation: this.operation,
+      status: this.status,
+      statusDescription: this.getStatusDescription(),
+      duration: this.duration,
+      formattedDuration: this.getFormattedDuration(),
+      timestamp: this.getFormattedTimestamp(),
+      message: this.message,
+      hasError: this.isFailed(),
+      isRecent: this.isRecent()
+    };
+  }
+
+  /**
+   * Convert installation log to plain object
+   * @returns {Object}
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      agentId: this.agentId,
+      operation: this.operation,
+      timestamp: this.timestamp.toISOString(),
+      status: this.status,
+      message: this.message,
+      duration: this.duration,
+      errorDetails: this.errorDetails
+    };
+  }
+
+  /**
+   * Create installation log from plain object
+   * @param {Object} data - Plain object data
+   * @returns {InstallationLog}
+   */
+  static fromJSON(data) {
+    return new InstallationLog({
+      ...data,
+      timestamp: data.timestamp ? new Date(data.timestamp) : new Date()
+    });
+  }
+
+  /**
+   * Create a new log entry for operation start
+   * @param {string} agentId - Agent identifier
+   * @param {string} operation - Operation type
+   * @param {string} message - Start message
+   * @returns {InstallationLog}
+   */
+  static createStart(agentId, operation, message = '') {
+    return new InstallationLog({
+      agentId,
+      operation,
+      status: OperationStatus.STARTED,
+      message: message || `Starting ${operation} for ${agentId}`,
+      duration: 0
+    });
+  }
+
+  /**
+   * Create a new log entry for successful completion
+   * @param {string} agentId - Agent identifier
+   * @param {string} operation - Operation type
+   * @param {string} message - Success message
+   * @param {number} duration - Operation duration
+   * @returns {InstallationLog}
+   */
+  static createSuccess(agentId, operation, message = '', duration = 0) {
+    return new InstallationLog({
+      agentId,
+      operation,
+      status: OperationStatus.COMPLETED,
+      message: message || `Successfully completed ${operation} for ${agentId}`,
+      duration
+    });
+  }
+
+  /**
+   * Create a new log entry for failed operation
+   * @param {string} agentId - Agent identifier
+   * @param {string} operation - Operation type
+   * @param {string} error - Error message
+   * @param {string} errorDetails - Detailed error information
+   * @param {number} duration - Operation duration
+   * @returns {InstallationLog}
+   */
+  static createFailure(agentId, operation, error, errorDetails = '', duration = 0) {
+    return new InstallationLog({
+      agentId,
+      operation,
+      status: OperationStatus.FAILED,
+      message: error || `Failed ${operation} for ${agentId}`,
+      errorDetails,
+      duration
+    });
+  }
+
+  /**
+   * Create a new log entry for timeout
+   * @param {string} agentId - Agent identifier
+   * @param {string} operation - Operation type
+   * @param {number} duration - Duration when timeout occurred
+   * @returns {InstallationLog}
+   */
+  static createTimeout(agentId, operation, duration = 0) {
+    return new InstallationLog({
+      agentId,
+      operation,
+      status: OperationStatus.TIMEOUT,
+      message: `${operation} for ${agentId} timed out`,
+      duration
+    });
+  }
+}
+
+module.exports = InstallationLog;