vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/verification/TestRequirementManager.js

@@ -0,0 +1,495 @@
+/**
+ * Test Requirement Manager
+ * 
+ * Manages test requirement files for agent verification.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Test requirement manager class
+ */
+class TestRequirementManager {
+  /**
+   * Create test requirement manager instance
+   * @param {Object} options - Manager options
+   */
+  constructor(options = {}) {
+    this.baseDir = options.baseDir || './temp/agents';
+    this.requirementPrefix = options.requirementPrefix || 'test-requirement';
+    this.cleanupDelay = options.cleanupDelay || 5000; // 5 seconds
+    this.maxRetries = options.maxRetries || 3;
+    this.retryDelay = options.retryDelay || 1000; // 1 second
+    this.logger = options.logger || null;
+  }
+
+  /**
+   * Create test requirement file
+   * @param {string} agentId - Agent identifier
+   * @param {Object} testConfig - Test configuration
+   * @returns {Promise<Object>} - File creation result
+   */
+  async createRequirementFile(agentId, testConfig = {}) {
+    const timestamp = Date.now();
+    const uniqueId = crypto.randomBytes(4).toString('hex');
+    const fileName = `${this.requirementPrefix}-${agentId}-${timestamp}-${uniqueId}.txt`;
+    const filePath = path.join(this.baseDir, fileName);
+    
+    const content = testConfig.content || `test-requirement-${agentId}-${timestamp}`;
+    
+    try {
+      // Ensure directory exists
+      await this.ensureDirectory(this.baseDir);
+      
+      // Write file with retry logic
+      await this.writeWithRetry(filePath, content);
+      
+      const result = {
+        success: true,
+        agentId,
+        fileName,
+        filePath,
+        content,
+        timestamp,
+        size: content.length
+      };
+      
+      if (this.logger) {
+        await this.logger.info('Test requirement file created', {
+          agentId,
+          fileName,
+          filePath,
+          size: result.size
+        });
+      }
+      
+      return result;
+    } catch (error) {
+      const errorResult = {
+        success: false,
+        agentId,
+        fileName,
+        error: error.message,
+        timestamp
+      };
+      
+      if (this.logger) {
+        await this.logger.error('Failed to create test requirement file', {
+          agentId,
+          fileName,
+          error: error.message
+        });
+      }
+      
+      throw new Error(`Failed to create test requirement file: ${error.message}`);
+    }
+  }
+
+  /**
+   * Read test requirement file
+   * @param {string} filePath - Path to file
+   * @returns {Promise<Object>} - File read result
+   */
+  async readRequirementFile(filePath) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const stats = await fs.stat(filePath);
+      
+      const result = {
+        success: true,
+        filePath,
+        content,
+        size: content.length,
+        modified: stats.mtime,
+        created: stats.birthtime
+      };
+      
+      if (this.logger) {
+        await this.logger.info('Test requirement file read', {
+          filePath,
+          size: result.size
+        });
+      }
+      
+      return result;
+    } catch (error) {
+      const errorResult = {
+        success: false,
+        filePath,
+        error: error.message
+      };
+      
+      if (this.logger) {
+        await this.logger.error('Failed to read test requirement file', {
+          filePath,
+          error: error.message
+        });
+      }
+      
+      throw new Error(`Failed to read test requirement file: ${error.message}`);
+    }
+  }
+
+  /**
+   * Verify test requirement file content
+   * @param {string} filePath - Path to file
+   * @param {string} expectedContent - Expected content
+   * @returns {Promise<Object>} - Verification result
+   */
+  async verifyRequirementFile(filePath, expectedContent) {
+    try {
+      const readResult = await this.readRequirementFile(filePath);
+      
+      if (!readResult.success) {
+        return readResult;
+      }
+      
+      const contentMatches = readResult.content === expectedContent;
+      
+      const result = {
+        success: true,
+        filePath,
+        expectedContent,
+        actualContent: readResult.content,
+        contentMatches,
+        verified: contentMatches,
+        size: readResult.size,
+        modified: readResult.modified
+      };
+      
+      if (this.logger) {
+        await this.logger.info('Test requirement file verified', {
+          filePath,
+          contentMatches,
+          size: result.size
+        });
+      }
+      
+      return result;
+    } catch (error) {
+      const errorResult = {
+        success: false,
+        filePath,
+        expectedContent,
+        error: error.message,
+        verified: false
+      };
+      
+      if (this.logger) {
+        await this.logger.error('Failed to verify test requirement file', {
+          filePath,
+          error: error.message
+        });
+      }
+      
+      return errorResult;
+    }
+  }
+
+  /**
+   * Delete test requirement file
+   * @param {string} filePath - Path to file
+   * @param {boolean} immediate - Delete immediately or with delay
+   * @returns {Promise<Object>} - Deletion result
+   */
+  async deleteRequirementFile(filePath, immediate = false) {
+    try {
+      if (!immediate && this.cleanupDelay > 0) {
+        // Schedule delayed cleanup
+        setTimeout(async () => {
+          try {
+            await fs.unlink(filePath);
+            
+            if (this.logger) {
+              await this.logger.info('Test requirement file cleaned up', {
+                filePath,
+                delayed: true
+              });
+            }
+          } catch (error) {
+            if (this.logger) {
+              await this.logger.warn('Failed to cleanup test requirement file', {
+                filePath,
+                error: error.message
+              });
+            }
+          }
+        }, this.cleanupDelay);
+        
+        return {
+          success: true,
+          filePath,
+          scheduled: true,
+          cleanupDelay: this.cleanupDelay
+        };
+      } else {
+        // Immediate deletion
+        await fs.unlink(filePath);
+        
+        const result = {
+          success: true,
+          filePath,
+          deleted: true,
+          immediate: true
+        };
+        
+        if (this.logger) {
+          await this.logger.info('Test requirement file deleted', {
+            filePath,
+            immediate: true
+          });
+        }
+        
+        return result;
+      }
+    } catch (error) {
+      const errorResult = {
+        success: false,
+        filePath,
+        error: error.message,
+        deleted: false
+      };
+      
+      if (this.logger) {
+        await this.logger.error('Failed to delete test requirement file', {
+          filePath,
+          error: error.message
+        });
+      }
+      
+      return errorResult;
+    }
+  }
+
+  /**
+   * Complete test requirement cycle (create, read, verify, delete)
+   * @param {string} agentId - Agent identifier
+   * @param {Object} testConfig - Test configuration
+   * @returns {Promise<Object>} - Cycle result
+   */
+  async completeRequirementCycle(agentId, testConfig = {}) {
+    const cycleId = crypto.randomBytes(8).toString('hex');
+    const startTime = Date.now();
+    
+    try {
+      // Create requirement file
+      const createResult = await this.createRequirementFile(agentId, testConfig);
+      
+      // Verify file content
+      const verifyResult = await this.verifyRequirementFile(
+        createResult.filePath,
+        createResult.content
+      );
+      
+      // Delete requirement file
+      const deleteResult = await this.deleteRequirementFile(createResult.filePath, false);
+      
+      const duration = Date.now() - startTime;
+      
+      const cycleResult = {
+        success: verifyResult.contentMatches && deleteResult.success,
+        cycleId,
+        agentId,
+        duration,
+        steps: {
+          create: createResult,
+          verify: verifyResult,
+          delete: deleteResult
+        },
+        summary: {
+          fileCreated: createResult.success,
+          contentVerified: verifyResult.contentMatches,
+          fileDeleted: deleteResult.success || deleteResult.scheduled,
+          allStepsPassed: createResult.success && verifyResult.contentMatches && (deleteResult.success || deleteResult.scheduled)
+        }
+      };
+      
+      if (this.logger) {
+        await this.logger.info('Test requirement cycle completed', {
+          cycleId,
+          agentId,
+          success: cycleResult.success,
+          duration,
+          summary: cycleResult.summary
+        });
+      }
+      
+      return cycleResult;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      const errorResult = {
+        success: false,
+        cycleId,
+        agentId,
+        duration,
+        error: error.message,
+        steps: {},
+        summary: {
+          fileCreated: false,
+          contentVerified: false,
+          fileDeleted: false,
+          allStepsPassed: false
+        }
+      };
+      
+      if (this.logger) {
+        await this.logger.error('Test requirement cycle failed', {
+          cycleId,
+          agentId,
+          error: error.message,
+          duration
+        });
+      }
+      
+      return errorResult;
+    }
+  }
+
+  /**
+   * Clean up old test requirement files
+   * @param {number} maxAge - Maximum age in milliseconds
+   * @returns {Promise<Object>} - Cleanup result
+   */
+  async cleanupOldFiles(maxAge = 3600000) { // 1 hour default
+    try {
+      await this.ensureDirectory(this.baseDir);
+      
+      const files = await fs.readdir(this.baseDir);
+      const now = Date.now();
+      let cleanedCount = 0;
+      let errorCount = 0;
+      
+      for (const file of files) {
+        if (file.startsWith(this.requirementPrefix)) {
+          const filePath = path.join(this.baseDir, file);
+          
+          try {
+            const stats = await fs.stat(filePath);
+            const age = now - stats.mtime.getTime();
+            
+            if (age > maxAge) {
+              await fs.unlink(filePath);
+              cleanedCount++;
+              
+              if (this.logger) {
+                await this.logger.info('Old test requirement file cleaned up', {
+                  file,
+                  age,
+                  maxAge
+                });
+              }
+            }
+          } catch (error) {
+            errorCount++;
+            
+            if (this.logger) {
+              await this.logger.warn('Failed to clean up old test file', {
+                file,
+                error: error.message
+              });
+            }
+          }
+        }
+      }
+      
+      return {
+        success: true,
+        totalFiles: files.length,
+        cleanedCount,
+        errorCount,
+        maxAge
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to cleanup old test files', {
+          error: error.message,
+          maxAge
+        });
+      }
+      
+      return {
+        success: false,
+        error: error.message,
+        maxAge
+      };
+    }
+  }
+
+  /**
+   * Ensure directory exists
+   * @param {string} dirPath - Directory path
+   */
+  async ensureDirectory(dirPath) {
+    try {
+      await fs.mkdir(dirPath, { recursive: true });
+    } catch (error) {
+      if (error.code !== 'EEXIST') {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Write file with retry logic
+   * @param {string} filePath - File path
+   * @param {string} content - File content
+   */
+  async writeWithRetry(filePath, content) {
+    let lastError;
+    
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        await fs.writeFile(filePath, content, 'utf8');
+        return;
+      } catch (error) {
+        lastError = error;
+        
+        if (attempt < this.maxRetries) {
+          await this.delay(this.retryDelay * attempt);
+        }
+      }
+    }
+    
+    throw lastError;
+  }
+
+  /**
+   * Delay helper
+   * @param {number} ms - Milliseconds to delay
+   */
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Get manager information
+   * @returns {Object} - Manager info
+   */
+  getInfo() {
+    return {
+      name: 'Test Requirement Manager',
+      version: '1.0.0',
+      baseDir: this.baseDir,
+      requirementPrefix: this.requirementPrefix,
+      cleanupDelay: this.cleanupDelay,
+      maxRetries: this.maxRetries,
+      retryDelay: this.retryDelay,
+      features: [
+        'file creation',
+        'file reading',
+        'content verification',
+        'file deletion',
+        'delayed cleanup',
+        'batch cleanup',
+        'retry logic',
+        'error handling'
+      ]
+    };
+  }
+}
+
+module.exports = TestRequirementManager;