vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/VerificationTest.js

@@ -0,0 +1,354 @@
+/**
+ * Verification Test Class
+ * 
+ * Represents a test to verify agent functionality.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { VerificationType } = require('./VerificationType');
+
+/**
+ * Verification test class for AI agents
+ */
+class VerificationTest {
+  /**
+   * Create a new VerificationTest instance
+   * @param {Object} config - Test configuration
+   * @param {string} config.id - Unique test identifier
+   * @param {string} config.agentId - Reference to Agent
+   * @param {string} config.type - Verification type
+   * @param {string} config.description - What this test verifies
+   * @param {string} config.command - Test command template
+   * @param {string} config.expectedResult - Expected output or behavior
+   * @param {number} config.timeout - Test timeout in seconds
+   */
+  constructor(config = {}) {
+    this.id = config.id || '';
+    this.agentId = config.agentId || '';
+    this.type = config.type || '';
+    this.description = config.description || '';
+    this.command = config.command || '';
+    this.expectedResult = config.expectedResult || '';
+    this.timeout = config.timeout || 30; // Default 30 seconds
+    
+    this.validate();
+  }
+
+  /**
+   * Validate verification test configuration
+   * @throws {Error} If configuration is invalid
+   */
+  validate() {
+    if (!this.id || typeof this.id !== 'string') {
+      throw new Error('Verification test must have a valid non-empty string id');
+    }
+    
+    if (!this.agentId || typeof this.agentId !== 'string') {
+      throw new Error('Verification test must have a valid non-empty string agentId');
+    }
+    
+    if (!this.type || typeof this.type !== 'string') {
+      throw new Error('Verification test must have a valid non-empty string 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('Verification test must have a valid non-empty string description');
+    }
+    
+    if (!this.command || typeof this.command !== 'string') {
+      throw new Error('Verification test must have a valid non-empty string command');
+    }
+    
+    if (!this.expectedResult || typeof this.expectedResult !== 'string') {
+      throw new Error('Verification test must have a valid non-empty string expectedResult');
+    }
+    
+    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 the verification test
+   * @param {Object} options - Test options
+   * @param {Object} options.context - Test context variables
+   * @returns {Promise<Object>} - Test result
+   */
+  async execute(options = {}) {
+    const { context = {} } = options;
+    
+    const startTime = Date.now();
+    
+    try {
+      const command = this.buildCommand(context);
+      const result = await this.runCommand(command);
+      const passed = this.evaluateResult(result);
+      
+      return {
+        id: this.id,
+        agentId: this.agentId,
+        type: this.type,
+        description: this.description,
+        passed,
+        command,
+        result,
+        duration: Date.now() - startTime,
+        timeout: this.timeout * 1000,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      return {
+        id: this.id,
+        agentId: this.agentId,
+        type: this.type,
+        description: this.description,
+        passed: false,
+        error: error.message,
+        duration: Date.now() - startTime,
+        timeout: this.timeout * 1000,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Run command with timeout
+   * @param {string} command - Command to run
+   * @returns {Promise<Object>} - Command result
+   */
+  async runCommand(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(`Test 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 test result against expected outcome
+   * @param {Object} result - Command result
+   * @returns {boolean} - True if test passed
+   */
+  evaluateResult(result) {
+    switch (this.type) {
+      case VerificationType.FILE_OPERATION:
+        return this.evaluateFileOperation(result);
+      case VerificationType.API_CALL:
+        return this.evaluateApiCall(result);
+      case VerificationType.COMMAND_EXECUTION:
+        return this.evaluateCommandExecution(result);
+      case VerificationType.NETWORK_TEST:
+        return this.evaluateNetworkTest(result);
+      default:
+        return this.evaluateDefault(result);
+    }
+  }
+
+  /**
+   * Evaluate file operation test
+   * @param {Object} result - Command result
+   * @returns {boolean}
+   */
+  evaluateFileOperation(result) {
+    // For file operations, check if command succeeded and output contains expected result
+    return result.success && result.stdout.includes(this.expectedResult);
+  }
+
+  /**
+   * Evaluate API call test
+   * @param {Object} result - Command result
+   * @returns {boolean}
+   */
+  evaluateApiCall(result) {
+    // For API calls, check success and expected response
+    return result.success && result.stdout.includes(this.expectedResult);
+  }
+
+  /**
+   * Evaluate command execution test
+   * @param {Object} result - Command result
+   * @returns {boolean}
+   */
+  evaluateCommandExecution(result) {
+    // For command execution, check if command runs without error
+    return result.success;
+  }
+
+  /**
+   * Evaluate network test
+   * @param {Object} result - Command result
+   * @returns {boolean}
+   */
+  evaluateNetworkTest(result) {
+    // For network tests, check connectivity and response
+    return result.success && result.stdout.includes(this.expectedResult);
+  }
+
+  /**
+   * Default evaluation method
+   * @param {Object} result - Command result
+   * @returns {boolean}
+   */
+  evaluateDefault(result) {
+    return result.success && result.stdout.includes(this.expectedResult);
+  }
+
+  /**
+   * Convert verification test to plain object
+   * @returns {Object}
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      agentId: this.agentId,
+      type: this.type,
+      description: this.description,
+      command: this.command,
+      expectedResult: this.expectedResult,
+      timeout: this.timeout
+    };
+  }
+
+  /**
+   * Create verification test from plain object
+   * @param {Object} data - Plain object data
+   * @returns {VerificationTest}
+   */
+  static fromJSON(data) {
+    return new VerificationTest(data);
+  }
+
+  /**
+   * Create common verification tests for agents
+   * @param {string} agentId - Agent identifier
+   * @param {string} type - Test type
+   * @returns {VerificationTest|null}
+   */
+  static createCommonTest(agentId, type) {
+    const tests = {
+      [VerificationType.FILE_OPERATION]: {
+        id: `${agentId}-file-op`,
+        description: 'Test file creation and deletion',
+        command: 'echo "test-requirement-{timestamp}" > test-requirement-{timestamp}.txt && cat test-requirement-{timestamp}.txt && rm test-requirement-{timestamp}.txt',
+        expectedResult: 'test-requirement-{timestamp}',
+        timeout: 10
+      },
+      [VerificationType.COMMAND_EXECUTION]: {
+        id: `${agentId}-cmd-exec`,
+        description: 'Test basic command execution',
+        command: '{agentCommand} --version',
+        expectedResult: 'version',
+        timeout: 15
+      },
+      [VerificationType.API_CALL]: {
+        id: `${agentId}-api-call`,
+        description: 'Test agent API functionality',
+        command: '{agentCommand} --help',
+        expectedResult: 'help',
+        timeout: 20
+      },
+      [VerificationType.NETWORK_TEST]: {
+        id: `${agentId}-network`,
+        description: 'Test network connectivity',
+        command: 'ping -c 1 google.com',
+        expectedResult: '1 received',
+        timeout: 30
+      }
+    };
+
+    const testConfig = tests[type];
+    if (!testConfig) {
+      return null;
+    }
+
+    return new VerificationTest({
+      agentId,
+      type,
+      ...testConfig
+    });
+  }
+
+  /**
+   * Create verification test suite for an agent
+   * @param {string} agentId - Agent identifier
+   * @param {string} agentCommand - Agent command to test
+   * @returns {VerificationTest[]} - Array of tests
+   */
+  static createTestSuite(agentId, agentCommand) {
+    const tests = [];
+    
+    // File operation test
+    const fileTest = this.createCommonTest(agentId, VerificationType.FILE_OPERATION);
+    if (fileTest) {
+      fileTest.command = fileTest.command.replace('{timestamp}', Date.now());
+      tests.push(fileTest);
+    }
+    
+    // Command execution test
+    const cmdTest = this.createCommonTest(agentId, VerificationType.COMMAND_EXECUTION);
+    if (cmdTest) {
+      cmdTest.command = cmdTest.command.replace('{agentCommand}', agentCommand);
+      tests.push(cmdTest);
+    }
+    
+    return tests;
+  }
+}
+
+module.exports = VerificationTest;

package/src/agents/VerificationType.js

@@ -0,0 +1,226 @@
+/**
+ * Verification Type Enumeration
+ * 
+ * Defines types of verification tests for agents.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Verification type enumeration
+ * These represent different approaches to testing agent functionality
+ */
+const VerificationType = {
+  // Create/read/delete test files
+  FILE_OPERATION: 'FILE_OPERATION',
+  
+  // Test agent API functionality
+  API_CALL: 'API_CALL',
+  
+  // Test basic command execution
+  COMMAND_EXECUTION: 'COMMAND_EXECUTION',
+  
+  // Test network connectivity
+  NETWORK_TEST: 'NETWORK_TEST',
+  
+  // Test agent communication with interactive setup
+  COMMUNICATION: 'COMMUNICATION'
+};
+
+/**
+ * Check if verification type requires file system access
+ * @param {string} type - Verification type to check
+ * @returns {boolean}
+ */
+function requiresFileSystemAccess(type) {
+  return type === VerificationType.FILE_OPERATION;
+}
+
+/**
+ * Check if verification type requires network access
+ * @param {string} type - Verification type to check
+ * @returns {boolean}
+ */
+function requiresNetworkAccess(type) {
+  return [VerificationType.NETWORK_TEST, VerificationType.COMMUNICATION].includes(type);
+}
+
+/**
+ * Check if verification type requires agent to be installed
+ * @param {string} type - Verification type to check
+ * @returns {boolean}
+ */
+function requiresAgentInstallation(type) {
+  return [VerificationType.API_CALL, VerificationType.COMMAND_EXECUTION, VerificationType.COMMUNICATION].includes(type);
+}
+
+/**
+ * Get verification type priority (lower numbers = higher priority)
+ * @param {string} type - Verification type
+ * @returns {number} - Priority value
+ */
+function getTypePriority(type) {
+  const priorities = {
+    [VerificationType.COMMAND_EXECUTION]: 1, // Basic functionality
+    [VerificationType.FILE_OPERATION]: 2, // File system interaction
+    [VerificationType.API_CALL]: 3, // Advanced functionality
+    [VerificationType.COMMUNICATION]: 3, // Communication testing
+    [VerificationType.NETWORK_TEST]: 4 // Network connectivity
+  };
+
+  return priorities[type] || 999;
+}
+
+/**
+ * Get verification type description
+ * @param {string} type - Verification type
+ * @returns {string} - Human-readable description
+ */
+function getTypeDescription(type) {
+  const descriptions = {
+    [VerificationType.FILE_OPERATION]: 'File create/read/delete test',
+    [VerificationType.API_CALL]: 'Agent API functionality test',
+    [VerificationType.COMMAND_EXECUTION]: 'Basic command execution test',
+    [VerificationType.COMMUNICATION]: 'Interactive communication test',
+    [VerificationType.NETWORK_TEST]: 'Network connectivity test'
+  };
+
+  return descriptions[type] || 'Unknown verification type';
+}
+
+/**
+ * Get all possible verification types
+ * @returns {string[]} - Array of all type values
+ */
+function getAllTypes() {
+  return Object.values(VerificationType);
+}
+
+/**
+ * Check if a value is a valid VerificationType
+ * @param {string} type - Type to validate
+ * @returns {boolean} - True if valid
+ */
+function isValidType(type) {
+  return getAllTypes().includes(type);
+}
+
+/**
+ * Get preferred verification types in order of execution
+ * @returns {string[]} - Array of types in priority order
+ */
+function getExecutionOrder() {
+  return getAllTypes().sort((a, b) => getTypePriority(a) - getTypePriority(b));
+}
+
+/**
+ * Get typical timeout values for each verification type
+ * @param {string} type - Verification type
+ * @returns {number} - Timeout in seconds
+ */
+function getDefaultTimeout(type) {
+  const timeouts = {
+    [VerificationType.FILE_OPERATION]: 10, // Quick file operations
+    [VerificationType.COMMAND_EXECUTION]: 15, // Command should be fast
+    [VerificationType.API_CALL]: 20, // API calls may take time
+    [VerificationType.COMMUNICATION]: 60, // Communication tests need more time
+    [VerificationType.NETWORK_TEST]: 30 // Network tests can be slow
+  };
+
+  return timeouts[type] || 30;
+}
+
+/**
+ * Get expected success indicators for each verification type
+ * @param {string} type - Verification type
+ * @returns {string[]} - Array of success indicators
+ */
+function getSuccessIndicators(type) {
+  const indicators = {
+    [VerificationType.FILE_OPERATION]: ['created', 'written', 'deleted', 'success'],
+    [VerificationType.API_CALL]: ['200', 'success', 'ok', 'completed'],
+    [VerificationType.COMMAND_EXECUTION]: ['version', 'help', 'ready', 'available'],
+    [VerificationType.COMMUNICATION]: ['hello', 'hi', 'greeting', 'response', 'received'],
+    [VerificationType.NETWORK_TEST]: ['received', 'reachable', 'connected', 'success']
+  };
+
+  return indicators[type] || ['success'];
+}
+
+/**
+ * Get common failure patterns for each verification type
+ * @param {string} type - Verification type
+ * @returns {string[]} - Array of failure patterns
+ */
+function getFailurePatterns(type) {
+  const patterns = {
+    [VerificationType.FILE_OPERATION]: ['permission denied', 'no such file', 'access denied'],
+    [VerificationType.API_CALL]: ['401', '403', '404', '500', 'error', 'failed'],
+    [VerificationType.COMMAND_EXECUTION]: ['command not found', 'not recognized', 'not installed'],
+    [VerificationType.COMMUNICATION]: ['no response', 'timeout', 'connection failed', 'authentication required'],
+    [VerificationType.NETWORK_TEST]: ['unreachable', 'timeout', 'connection refused', 'dns']
+  };
+
+  return patterns[type] || ['error', 'failed'];
+}
+
+/**
+ * Check if verification type is safe to run in parallel
+ * @param {string} type - Verification type
+ * @returns {boolean} - True if safe for parallel execution
+ */
+function isSafeForParallel(type) {
+  // File operations and communication tests may conflict, others are generally safe
+  return ![VerificationType.FILE_OPERATION, VerificationType.COMMUNICATION].includes(type);
+}
+
+/**
+ * Get verification type requirements
+ * @param {string} type - Verification type
+ * @returns {string[]} - Array of requirements
+ */
+function getRequirements(type) {
+  const requirements = {
+    [VerificationType.FILE_OPERATION]: ['file system', 'write permissions'],
+    [VerificationType.API_CALL]: ['agent installation', 'api access'],
+    [VerificationType.COMMAND_EXECUTION]: ['agent installation', 'command line'],
+    [VerificationType.COMMUNICATION]: ['agent installation', 'network connection', 'authentication'],
+    [VerificationType.NETWORK_TEST]: ['internet connection']
+  };
+
+  return requirements[type] || [];
+}
+
+/**
+ * Get verification type cleanup requirements
+ * @param {string} type - Verification type
+ * @returns {string[]} - Array of cleanup actions
+ */
+function getCleanupRequirements(type) {
+  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.COMMUNICATION]: ['close communication sessions', 'reset authentication state'],
+    [VerificationType.NETWORK_TEST]: ['close network connections', 'clear dns cache']
+  };
+
+  return cleanup[type] || [];
+}
+
+module.exports = {
+  VerificationType,
+  requiresFileSystemAccess,
+  requiresNetworkAccess,
+  requiresAgentInstallation,
+  getTypePriority,
+  getTypeDescription,
+  getAllTypes,
+  isValidType,
+  getExecutionOrder,
+  getDefaultTimeout,
+  getSuccessIndicators,
+  getFailurePatterns,
+  isSafeForParallel,
+  getRequirements,
+  getCleanupRequirements
+};