vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/verification/BaseVerifier.js

@@ -0,0 +1,430 @@
+/**
+ * Base Verification Interface
+ * 
+ * Abstract base class for agent verifiers.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { VerificationType } = require('../VerificationType');
+const { OperationType, OperationStatus } = require('../OperationTypes');
+
+/**
+ * Abstract base class for agent verifiers
+ */
+class BaseVerifier {
+  /**
+   * Create verifier instance
+   * @param {Object} config - Verifier configuration
+   * @param {string} config.type - Verification type
+   * @param {string} config.description - Verification description
+   * @param {string} config.command - Verification command
+   * @param {string} config.expectedResult - Expected result
+   * @param {number} config.timeout - Timeout in seconds
+   * @param {AgentLogger} config.logger - Logger instance
+   */
+  constructor(config = {}) {
+    this.type = config.type || '';
+    this.description = config.description || '';
+    this.command = config.command || '';
+    this.expectedResult = config.expectedResult || '';
+    this.timeout = config.timeout || 30;
+    this.logger = config.logger;
+    
+    this.validate();
+  }
+
+  /**
+   * Validate verifier configuration
+   * @throws {Error} If configuration is invalid
+   */
+  validate() {
+    if (!this.type || typeof this.type !== 'string') {
+      throw new Error('Verifier must have a valid type');
+    }
+    
+    if (!Object.values(VerificationType).includes(this.type)) {
+      throw new Error(`Invalid verification type: ${this.type}`);
+    }
+    
+    if (!this.description || typeof this.description !== 'string') {
+      throw new Error('Verifier must have a valid description');
+    }
+    
+    if (!this.command || typeof this.command !== 'string') {
+      throw new Error('Verifier must have a valid command');
+    }
+    
+    if (!this.expectedResult || typeof this.expectedResult !== 'string') {
+      throw new Error('Verifier must have a valid expected result');
+    }
+    
+    if (typeof this.timeout !== 'number' || this.timeout < 1 || this.timeout > 300) {
+      throw new Error('Timeout must be a number between 1 and 300 seconds');
+    }
+  }
+
+  /**
+   * Execute verification test
+   * @param {Object} options - Verification options
+   * @param {Object} options.context - Test context variables
+   * @param {string} options.agentId - Agent identifier
+   * @returns {Promise<Object>} - Verification result
+   */
+  async verify(options = {}) {
+    const { context = {}, agentId = '' } = options;
+    
+    if (this.logger) {
+      await this.logger.info(`Starting verification: ${this.description}`, {
+        type: this.type,
+        agentId,
+        description: this.description
+      });
+    }
+
+    const startTime = Date.now();
+    
+    try {
+      // Build command with context
+      const command = this.buildCommand(context);
+      
+      // Execute verification
+      const result = await this.executeVerification(command);
+      
+      // Evaluate result
+      const passed = this.evaluateResult(result);
+      
+      const verificationResult = {
+        id: this.generateId(),
+        agentId,
+        type: this.type,
+        description: this.description,
+        passed,
+        command,
+        result,
+        duration: Date.now() - startTime,
+        timeout: this.timeout * 1000,
+        timestamp: new Date().toISOString()
+      };
+
+      if (this.logger) {
+        const level = passed ? 'info' : 'warn';
+        const message = passed 
+          ? `Verification passed: ${this.description}`
+          : `Verification failed: ${this.description}`;
+        
+        await this.logger[level](message, {
+          type: this.type,
+          agentId,
+          passed,
+          duration: verificationResult.duration
+        });
+      }
+
+      return verificationResult;
+    } catch (error) {
+      const errorResult = {
+        id: this.generateId(),
+        agentId,
+        type: this.type,
+        description: this.description,
+        passed: false,
+        error: error.message,
+        duration: Date.now() - startTime,
+        timeout: this.timeout * 1000,
+        timestamp: new Date().toISOString()
+      };
+
+      if (this.logger) {
+        await this.logger.error(`Verification error: ${this.description}`, {
+          type: this.type,
+          agentId,
+          error: error.message,
+          duration: errorResult.duration
+        });
+      }
+
+      return errorResult;
+    }
+  }
+
+  /**
+   * Generate unique verification ID
+   * @returns {string} - Unique identifier
+   */
+  generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substr(2, 9);
+    return `verify-${this.type}-${timestamp}-${random}`;
+  }
+
+  /**
+   * Build command with context variables
+   * @param {Object} context - Context variables
+   * @returns {string} - Resolved command
+   */
+  buildCommand(context) {
+    let command = this.command;
+    
+    // Replace common placeholders
+    Object.entries(context).forEach(([key, value]) => {
+      const placeholder = `{${key}}`;
+      command = command.replace(new RegExp(placeholder, 'g'), value);
+    });
+    
+    return command;
+  }
+
+  /**
+   * Execute verification command
+   * @param {string} command - Command to execute
+   * @returns {Promise<Object>} - Command result
+   */
+  async executeVerification(command) {
+    return new Promise((resolve, reject) => {
+      const { spawn } = require('child_process');
+      
+      const child = spawn(command, [], { 
+        shell: true,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      
+      let stdout = '';
+      let stderr = '';
+      
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+      
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        reject(new Error(`Verification command timed out after ${this.timeout} seconds`));
+      }, this.timeout * 1000);
+      
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        
+        resolve({
+          exitCode: code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          success: code === 0
+        });
+      });
+      
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Evaluate verification result
+   * @param {Object} result - Command result
+   * @returns {boolean} - True if verification passed
+   */
+  evaluateResult(result) {
+    // Default evaluation - check if command succeeded and output contains expected result
+    return result.success && this.containsExpectedResult(result.stdout);
+  }
+
+  /**
+   * Check if output contains expected result
+   * @param {string} output - Command output
+   * @returns {boolean} - True if expected result found
+   */
+  containsExpectedResult(output) {
+    if (!output || !this.expectedResult) {
+      return false;
+    }
+
+    // Case-insensitive search
+    const outputLower = output.toLowerCase();
+    const expectedLower = this.expectedResult.toLowerCase();
+    
+    return outputLower.includes(expectedLower);
+  }
+
+  /**
+   * Check if verification is safe to run in parallel
+   * @returns {boolean} - True if safe for parallel execution
+   */
+  isSafeForParallel() {
+    // Default implementation - check verification type
+    switch (this.type) {
+      case VerificationType.FILE_OPERATION:
+        return false; // File operations may conflict
+      case VerificationType.API_CALL:
+        return true; // API calls are generally safe
+      case VerificationType.COMMAND_EXECUTION:
+        return true; // Command execution is generally safe
+      case VerificationType.NETWORK_TEST:
+        return true; // Network tests are safe
+      default:
+        return true;
+    }
+  }
+
+  /**
+   * Get verification requirements
+   * @returns {string[]} - Array of requirements
+   */
+  getRequirements() {
+    const requirements = {
+      [VerificationType.FILE_OPERATION]: ['file system', 'write permissions'],
+      [VerificationType.API_CALL]: ['agent installation', 'api access'],
+      [VerificationType.COMMAND_EXECUTION]: ['agent installation', 'command line'],
+      [VerificationType.NETWORK_TEST]: ['internet connection']
+    };
+
+    return requirements[this.type] || [];
+  }
+
+  /**
+   * Get cleanup requirements
+   * @returns {string[]} - Array of cleanup actions
+   */
+  getCleanupRequirements() {
+    const cleanup = {
+      [VerificationType.FILE_OPERATION]: ['remove test files', 'clean temporary directories'],
+      [VerificationType.API_CALL]: ['clear api sessions', 'reset authentication'],
+      [VerificationType.COMMAND_EXECUTION]: ['clear command history', 'reset environment'],
+      [VerificationType.NETWORK_TEST]: ['close network connections', 'clear dns cache']
+    };
+
+    return cleanup[this.type] || [];
+  }
+
+  /**
+   * Perform cleanup after verification
+   * @param {Object} context - Verification context
+   * @returns {Promise<void>}
+   */
+  async cleanup(context = {}) {
+    if (this.logger) {
+      await this.logger.debug(`Performing cleanup for ${this.type} verification`);
+    }
+
+    const cleanupActions = this.getCleanupRequirements();
+    
+    for (const action of cleanupActions) {
+      try {
+        await this.performCleanupAction(action, context);
+      } catch (error) {
+        if (this.logger) {
+          await this.logger.warn(`Cleanup action failed: ${action}`, {
+            action,
+            error: error.message
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Perform a specific cleanup action
+   * @param {string} action - Cleanup action to perform
+   * @param {Object} context - Verification context
+   * @returns {Promise<void>}
+   */
+  async performCleanupAction(action, context) {
+    // Default implementation - override in subclasses for specific cleanup
+    switch (action) {
+      case 'remove test files':
+        await this.removeTestFiles(context);
+        break;
+      case 'clear api sessions':
+        // API session cleanup would be implemented in specific verifier
+        break;
+      default:
+        // Unknown cleanup action - ignore
+        break;
+    }
+  }
+
+  /**
+   * Remove test files created during verification
+   * @param {Object} context - Verification context
+   * @returns {Promise<void>}
+   */
+  async removeTestFiles(context) {
+    const { spawn } = require('child_process');
+    
+    // Remove common test file patterns
+    const testFilePatterns = [
+      'test-requirement-*.txt',
+      'temp-verification-*.tmp',
+      'agent-test-*.log'
+    ];
+
+    for (const pattern of testFilePatterns) {
+      try {
+        const command = process.platform === 'win32' 
+          ? `del /Q ${pattern} 2>nul`
+          : `rm -f ${pattern} 2>/dev/null`;
+        
+        await new Promise((resolve, reject) => {
+          const child = spawn(command, [], { shell: true, stdio: 'ignore' });
+          child.on('close', resolve);
+          child.on('error', reject);
+        });
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  /**
+   * Get verifier information
+   * @returns {Object} - Verifier information
+   */
+  getInfo() {
+    return {
+      type: this.type,
+      description: this.description,
+      command: this.command,
+      expectedResult: this.expectedResult,
+      timeout: this.timeout,
+      requirements: this.getRequirements(),
+      cleanupRequirements: this.getCleanupRequirements(),
+      safeForParallel: this.isSafeForParallel()
+    };
+  }
+
+  /**
+   * Create verifier instance from configuration
+   * @param {Object} config - Configuration object
+   * @param {AgentLogger} logger - Logger instance
+   * @returns {BaseVerifier} - Verifier instance
+   */
+  static fromConfig(config, logger = null) {
+    const verifierConfig = {
+      ...config,
+      logger
+    };
+    
+    // Return appropriate verifier subclass based on type
+    switch (config.type) {
+      case VerificationType.FILE_OPERATION:
+        const FileOperationVerifier = require('./FileOperationVerifier');
+        return new FileOperationVerifier(verifierConfig);
+      case VerificationType.API_CALL:
+        const ApiCallVerifier = require('./ApiCallVerifier');
+        return new ApiCallVerifier(verifierConfig);
+      case VerificationType.COMMAND_EXECUTION:
+        const CommandVerifier = require('./CommandVerifier');
+        return new CommandVerifier(verifierConfig);
+      case VerificationType.NETWORK_TEST:
+        const NetworkVerifier = require('./NetworkVerifier');
+        return new NetworkVerifier(verifierConfig);
+      default:
+        throw new Error(`Unknown verifier type: ${config.type}`);
+    }
+  }
+}
+
+module.exports = BaseVerifier;