vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/logging/AgentLogger.js

@@ -0,0 +1,511 @@
+/**
+ * Agent Logger
+ * 
+ * Provides structured logging for agent operations.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const FileManager = require('../storage/FileManager');
+
+/**
+ * Agent logger class for structured logging
+ */
+class AgentLogger {
+  /**
+   * Create logger instance
+   * @param {Object} options - Logger options
+   * @param {string} options.logLevel - Minimum log level
+   * @param {FileManager} options.fileManager - File manager instance
+   * @param {boolean} options.console - Enable console logging
+   */
+  constructor(options = {}) {
+    this.logLevel = options.logLevel || 'info';
+    this.fileManager = options.fileManager || new FileManager();
+    this.console = options.console !== false;
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3
+    };
+  }
+
+  /**
+   * Check if log level should be logged
+   * @param {string} level - Log level to check
+   * @returns {boolean} - True if should log
+   */
+  shouldLog(level) {
+    return this.levels[level] <= this.levels[this.logLevel];
+  }
+
+  /**
+   * Format log message
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @param {Object} meta - Additional metadata
+   * @returns {Object} - Formatted log entry
+   */
+  formatMessage(level, message, meta = {}) {
+    return {
+      level: level.toUpperCase(),
+      message,
+      timestamp: new Date().toISOString(),
+      ...meta
+    };
+  }
+
+  /**
+   * Write log to file
+   * @param {string} level - Log level
+   * @param {Object} logEntry - Log entry
+   * @returns {Promise<void>}
+   */
+  async writeToFile(level, logEntry) {
+    try {
+      await this.fileManager.writeLog('agent', logEntry);
+    } catch (error) {
+      // Fallback to console if file logging fails
+      if (this.console) {
+        console.error('Failed to write log to file:', error.message);
+      }
+    }
+  }
+
+  /**
+   * Log error message
+   * @param {string} message - Error message
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async error(message, meta = {}) {
+    if (!this.shouldLog('error')) return;
+
+    const logEntry = this.formatMessage('error', message, meta);
+    
+    if (this.console) {
+      console.error(`[ERROR] ${logEntry.timestamp} - ${message}`, meta);
+    }
+    
+    await this.writeToFile('error', logEntry);
+  }
+
+  /**
+   * Log warning message
+   * @param {string} message - Warning message
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async warn(message, meta = {}) {
+    if (!this.shouldLog('warn')) return;
+
+    const logEntry = this.formatMessage('warn', message, meta);
+    
+    if (this.console) {
+      console.warn(`[WARN] ${logEntry.timestamp} - ${message}`, meta);
+    }
+    
+    await this.writeToFile('agent', logEntry);
+  }
+
+  /**
+   * Log info message
+   * @param {string} message - Info message
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async info(message, meta = {}) {
+    if (!this.shouldLog('info')) return;
+
+    const logEntry = this.formatMessage('info', message, meta);
+    
+    if (this.console) {
+      console.info(`[INFO] ${logEntry.timestamp} - ${message}`, meta);
+    }
+    
+    await this.writeToFile('agent', logEntry);
+  }
+
+  /**
+   * Log debug message
+   * @param {string} message - Debug message
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async debug(message, meta = {}) {
+    if (!this.shouldLog('debug')) return;
+
+    const logEntry = this.formatMessage('debug', message, meta);
+    
+    if (this.console) {
+      console.debug(`[DEBUG] ${logEntry.timestamp} - ${message}`, meta);
+    }
+    
+    await this.writeToFile('debug', logEntry);
+  }
+
+  /**
+   * Log agent operation start
+   * @param {string} agentId - Agent identifier
+   * @param {string} operation - Operation type
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logOperationStart(agentId, operation, meta = {}) {
+    await this.info(`Starting ${operation} for agent ${agentId}`, {
+      agentId,
+      operation,
+      phase: 'start',
+      ...meta
+    });
+  }
+
+  /**
+   * Log agent operation success
+   * @param {string} agentId - Agent identifier
+   * @param {string} operation - Operation type
+   * @param {number} duration - Operation duration in milliseconds
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logOperationSuccess(agentId, operation, duration, meta = {}) {
+    await this.info(`Successfully completed ${operation} for agent ${agentId}`, {
+      agentId,
+      operation,
+      duration,
+      phase: 'success',
+      ...meta
+    });
+  }
+
+  /**
+   * Log agent operation failure
+   * @param {string} agentId - Agent identifier
+   * @param {string} operation - Operation type
+   * @param {Error|string} error - Error details
+   * @param {number} duration - Operation duration in milliseconds
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logOperationFailure(agentId, operation, error, duration, meta = {}) {
+    const errorMessage = error instanceof Error ? error.message : error;
+    const errorStack = error instanceof Error ? error.stack : undefined;
+
+    await this.error(`Failed ${operation} for agent ${agentId}: ${errorMessage}`, {
+      agentId,
+      operation,
+      duration,
+      phase: 'failure',
+      error: errorMessage,
+      stack: errorStack,
+      ...meta
+    });
+  }
+
+  /**
+   * Log agent operation timeout
+   * @param {string} agentId - Agent identifier
+   * @param {string} operation - Operation type
+   * @param {number} timeout - Timeout duration in milliseconds
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logOperationTimeout(agentId, operation, timeout, meta = {}) {
+    await this.warn(`Operation ${operation} for agent ${agentId} timed out after ${timeout}ms`, {
+      agentId,
+      operation,
+      timeout,
+      phase: 'timeout',
+      ...meta
+    });
+  }
+
+  /**
+   * Log installation method attempt
+   * @param {string} agentId - Agent identifier
+   * @param {string} methodType - Installation method type
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logInstallationAttempt(agentId, methodType, meta = {}) {
+    await this.info(`Attempting installation of ${agentId} using ${methodType}`, {
+      agentId,
+      methodType,
+      phase: 'installation_attempt',
+      ...meta
+    });
+  }
+
+  /**
+   * Log verification test result
+   * @param {string} agentId - Agent identifier
+   * @param {string} testType - Test type
+   * @param {boolean} passed - Test result
+   * @param {number} duration - Test duration in milliseconds
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logVerificationResult(agentId, testType, passed, duration, meta = {}) {
+    const level = passed ? 'info' : 'warn';
+    const message = passed 
+      ? `Verification ${testType} passed for ${agentId}`
+      : `Verification ${testType} failed for ${agentId}`;
+
+    await this[level](message, {
+      agentId,
+      testType,
+      passed,
+      duration,
+      phase: 'verification',
+      ...meta
+    });
+  }
+
+  /**
+   * Log agent status change
+   * @param {string} agentId - Agent identifier
+   * @param {string} oldStatus - Previous status
+   * @param {string} newStatus - New status
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logStatusChange(agentId, oldStatus, newStatus, meta = {}) {
+    await this.info(`Agent ${agentId} status changed from ${oldStatus} to ${newStatus}`, {
+      agentId,
+      oldStatus,
+      newStatus,
+      phase: 'status_change',
+      ...meta
+    });
+  }
+
+  /**
+   * Log system requirements check
+   * @param {string} agentId - Agent identifier
+   * @param {string} methodType - Installation method type
+   * @param {Object} requirements - Requirements check result
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logRequirementsCheck(agentId, methodType, requirements, meta = {}) {
+    const level = requirements.allMet ? 'info' : 'warn';
+    const message = requirements.allMet
+      ? `All requirements met for ${agentId} using ${methodType}`
+      : `Some requirements not met for ${agentId} using ${methodType}`;
+
+    await this[level](message, {
+      agentId,
+      methodType,
+      requirements,
+      phase: 'requirements_check',
+      ...meta
+    });
+  }
+
+  /**
+   * Log detailed verification analysis
+   * @param {string} agentId - Agent identifier
+   * @param {Object} analysis - Verification analysis result
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logVerificationAnalysis(agentId, analysis, meta = {}) {
+    const level = analysis.overallSuccess ? 'info' : 'warn';
+    const message = analysis.overallSuccess
+      ? `Verification analysis completed for ${agentId}`
+      : `Verification analysis indicates issues for ${agentId}`;
+
+    await this[level](message, {
+      agentId,
+      analysis: {
+        status: analysis.status,
+        confidence: analysis.confidence,
+        issues: analysis.issues?.length || 0,
+        recommendations: analysis.recommendations?.length || 0
+      },
+      phase: 'verification_analysis',
+      ...meta
+    });
+  }
+
+  /**
+   * Log communication test cycle
+   * @param {string} agentId - Agent identifier
+   * @param {Object} cycleResult - Communication test cycle result
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logCommunicationCycle(agentId, cycleResult, meta = {}) {
+    const level = cycleResult.success ? 'info' : 'warn';
+    const message = cycleResult.success
+      ? `Communication test cycle completed for ${agentId}`
+      : `Communication test cycle failed for ${agentId}`;
+
+    await this[level](message, {
+      agentId,
+      cycleId: cycleResult.cycleId,
+      success: cycleResult.success,
+      duration: cycleResult.duration,
+      summary: cycleResult.summary,
+      phase: 'communication_cycle',
+      ...meta
+    });
+  }
+
+  /**
+   * Log test requirement management
+   * @param {string} operation - Operation type (create, read, verify, delete, cleanup)
+   * @param {Object} result - Operation result
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logTestRequirement(operation, result, meta = {}) {
+    const level = result.success ? 'info' : 'warn';
+    const message = result.success
+      ? `Test requirement ${operation} completed`
+      : `Test requirement ${operation} failed`;
+
+    await this[level](message, {
+      operation,
+      agentId: result.agentId,
+      fileName: result.fileName,
+      filePath: result.filePath,
+      success: result.success,
+      duration: result.duration,
+      phase: 'test_requirement',
+      ...meta
+    });
+  }
+
+  /**
+   * Log verification batch operation
+   * @param {string} operation - Batch operation type
+   * @param {Object} batchResult - Batch operation result
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logVerificationBatch(operation, batchResult, meta = {}) {
+    const level = batchResult.success ? 'info' : 'warn';
+    const message = batchResult.success
+      ? `Verification batch ${operation} completed`
+      : `Verification batch ${operation} failed`;
+
+    await this[level](message, {
+      operation,
+      batchId: batchResult.batchId,
+      totalAgents: batchResult.summary?.totalAgents || 0,
+      successfulAgents: batchResult.summary?.successfulAgents || 0,
+      failedAgents: batchResult.summary?.failedAgents || 0,
+      duration: batchResult.duration,
+      phase: 'verification_batch',
+      ...meta
+    });
+  }
+
+  /**
+   * Log performance metrics
+   * @param {string} operation - Operation type
+   * @param {Object} metrics - Performance metrics
+   * @param {Object} meta - Additional metadata
+   * @returns {Promise<void>}
+   */
+  async logPerformance(operation, metrics, meta = {}) {
+    await this.info(`Performance metrics for ${operation}`, {
+      operation,
+      metrics,
+      phase: 'performance',
+      ...meta
+    });
+  }
+
+  /**
+   * Create child logger with additional context
+   * @param {Object} context - Additional context for child logger
+   * @returns {AgentLogger} - Child logger instance
+   */
+  child(context = {}) {
+    const childLogger = new AgentLogger({
+      logLevel: this.logLevel,
+      fileManager: this.fileManager,
+      console: this.console
+    });
+    
+    // Add context to all log messages
+    childLogger.context = context;
+    
+    // Override log methods to include context
+    ['error', 'warn', 'info', 'debug'].forEach(level => {
+      const originalMethod = childLogger[level];
+      childLogger[level] = async (message, meta = {}) => {
+        await originalMethod.call(childLogger, message, { ...this.context, ...meta });
+      };
+    });
+    
+    return childLogger;
+  }
+
+  /**
+   * Get recent logs for an agent
+   * @param {string} agentId - Agent identifier
+   * @param {Object} options - Query options
+   * @returns {Promise<Array>} - Array of log entries
+   */
+  async getAgentLogs(agentId, options = {}) {
+    const { limit = 50, level = null, since = null } = options;
+    
+    const logs = await this.fileManager.readLogs('agent', {
+      limit: limit * 3, // Get more to filter
+      since
+    });
+    
+    return logs
+      .filter(log => log.agentId === agentId)
+      .filter(log => !level || log.level === level.toUpperCase())
+      .slice(0, limit);
+  }
+
+  /**
+   * Get error logs
+   * @param {Object} options - Query options
+   * @returns {Promise<Array>} - Array of error log entries
+   */
+  async getErrorLogs(options = {}) {
+    const { limit = 50, since = null } = options;
+    
+    return await this.fileManager.readLogs('error', {
+      limit,
+      since
+    });
+  }
+
+  /**
+   * Clean old logs
+   * @param {number} olderThanDays - Remove logs older than this many days
+   * @returns {Promise<Object>} - Cleanup results
+   */
+  async cleanOldLogs(olderThanDays = 30) {
+    const results = {};
+    
+    try {
+      results.agent = await this.fileManager.cleanOldLogs('agent', olderThanDays);
+    } catch (error) {
+      results.agent = { error: error.message };
+    }
+    
+    try {
+      results.error = await this.fileManager.cleanOldLogs('error', olderThanDays);
+    } catch (error) {
+      results.error = { error: error.message };
+    }
+    
+    try {
+      results.debug = await this.fileManager.cleanOldLogs('debug', olderThanDays);
+    } catch (error) {
+      results.debug = { error: error.message };
+    }
+    
+    return results;
+  }
+}
+
+module.exports = AgentLogger;