vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/agents/verification/FileOperationVerifier.js

@@ -0,0 +1,453 @@
+/**
+ * File Operation Verifier
+ * 
+ * File create/read/delete verification implementation.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const BaseVerifier = require('./BaseVerifier');
+const { VerificationType } = require('../VerificationType');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+/**
+ * File operation verifier class
+ */
+class FileOperationVerifier extends BaseVerifier {
+  /**
+   * Create file operation verifier instance
+   * @param {Object} config - Verifier configuration
+   */
+  constructor(config = {}) {
+    super({
+      type: VerificationType.FILE_OPERATION,
+      description: 'File create/read/delete test',
+      command: config.command || 'echo "test-requirement-{timestamp}" > test-requirement-{timestamp}.txt && cat test-requirement-{timestamp}.txt && rm test-requirement-{timestamp}.txt',
+      expectedResult: config.expectedResult || 'test-requirement-{timestamp}',
+      timeout: config.timeout || 10,
+      ...config
+    });
+    
+    this.testDir = config.testDir || os.tmpdir();
+    this.testFileName = config.testFileName || 'test-requirement-{timestamp}.txt';
+    this.cleanupOnSuccess = config.cleanupOnSuccess !== false;
+  }
+
+  /**
+   * Execute file operation verification
+   * @param {Object} options - Verification options
+   * @returns {Promise<Object>} - Verification result
+   */
+  async verify(options = {}) {
+    const { context = {} } = options;
+    
+    if (this.logger) {
+      await this.logger.info('Starting file operation verification', {
+        testDir: this.testDir,
+        testFileName: this.testFileName,
+        context
+      });
+    }
+
+    const startTime = Date.now();
+    
+    try {
+      // Generate unique timestamp for this test
+      const timestamp = Date.now();
+      const testContext = { ...context, timestamp };
+      
+      // Build test file path
+      const testFilePath = this.buildTestFilePath(timestamp);
+      
+      // Execute file operations
+      const result = await this.executeFileOperations(testFilePath, testContext);
+      
+      const verificationResult = {
+        id: this.generateId(),
+        agentId: options.agentId || '',
+        type: this.type,
+        description: this.description,
+        passed: result.success,
+        command: this.command,
+        result,
+        duration: Date.now() - startTime,
+        timeout: this.timeout * 1000,
+        timestamp: new Date().toISOString(),
+        testFilePath,
+        operations: result.operations || []
+      };
+
+      if (this.logger) {
+        const level = result.success ? 'info' : 'warn';
+        const message = result.success 
+          ? 'File operation verification passed'
+          : 'File operation verification failed';
+        
+        await this.logger[level](message, {
+          agentId: options.agentId,
+          passed: result.success,
+          duration: verificationResult.duration,
+          testFilePath
+        });
+      }
+
+      // Cleanup if successful and cleanup is enabled
+      if (result.success && this.cleanupOnSuccess) {
+        await this.cleanup(testFilePath, testContext);
+      }
+
+      return verificationResult;
+    } catch (error) {
+      const errorResult = {
+        id: this.generateId(),
+        agentId: options.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('File operation verification error', {
+          agentId: options.agentId,
+          error: error.message,
+          duration: errorResult.duration
+        });
+      }
+
+      return errorResult;
+    }
+  }
+
+  /**
+   * Execute file operations for verification
+   * @param {string} testFilePath - Test file path
+   * @param {Object} context - Test context
+   * @returns {Promise<Object>} - Operation result
+   */
+  async executeFileOperations(testFilePath, context) {
+    const operations = [];
+    
+    try {
+      // Operation 1: Create file
+      await this.createTestFile(testFilePath, context);
+      operations.push({
+        type: 'create',
+        path: testFilePath,
+        success: true,
+        timestamp: new Date().toISOString()
+      });
+
+      // Operation 2: Read file
+      const content = await this.readTestFile(testFilePath);
+      operations.push({
+        type: 'read',
+        path: testFilePath,
+        success: true,
+        content: content,
+        timestamp: new Date().toISOString()
+      });
+
+      // Operation 3: Verify content
+      const expectedContent = this.getExpectedContent(context);
+      const contentMatches = this.verifyContent(content, expectedContent);
+      operations.push({
+        type: 'verify',
+        path: testFilePath,
+        success: contentMatches,
+        expected: expectedContent,
+        actual: content,
+        timestamp: new Date().toISOString()
+      });
+
+      // Operation 4: Delete file
+      await this.deleteTestFile(testFilePath);
+      operations.push({
+        type: 'delete',
+        path: testFilePath,
+        success: true,
+        timestamp: new Date().toISOString()
+      });
+
+      return {
+        success: contentMatches,
+        operations,
+        testFilePath
+      };
+    } catch (error) {
+      // Add failed operation
+      operations.push({
+        type: 'error',
+        error: error.message,
+        timestamp: new Date().toISOString()
+      });
+
+      return {
+        success: false,
+        operations,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Build test file path with timestamp
+   * @param {number} timestamp - Timestamp for uniqueness
+   * @returns {string} - Test file path
+   */
+  buildTestFilePath(timestamp) {
+    const fileName = this.testFileName.replace('{timestamp}', timestamp.toString());
+    return path.join(this.testDir, fileName);
+  }
+
+  /**
+   * Create test file with content
+   * @param {string} filePath - File path
+   * @param {Object} context - Test context
+   */
+  async createTestFile(filePath, context) {
+    const content = this.getTestContent(context);
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  /**
+   * Get test content based on context
+   * @param {Object} context - Test context
+   * @returns {string} - Test content
+   */
+  getTestContent(context) {
+    const timestamp = context.timestamp || Date.now();
+    return `test-requirement-${timestamp}`;
+  }
+
+  /**
+   * Get expected content for verification
+   * @param {Object} context - Test context
+   * @returns {string} - Expected content
+   */
+  getExpectedContent(context) {
+    const timestamp = context.timestamp || Date.now();
+    return `test-requirement-${timestamp}`;
+  }
+
+  /**
+   * Read test file content
+   * @param {string} filePath - File path
+   * @returns {Promise<string>} - File content
+   */
+  async readTestFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    return content.trim();
+  }
+
+  /**
+   * Verify file content matches expected
+   * @param {string} actual - Actual content
+   * @param {string} expected - Expected content
+   * @returns {boolean} - True if content matches
+   */
+  verifyContent(actual, expected) {
+    return actual === expected;
+  }
+
+  /**
+   * Delete test file
+   * @param {string} filePath - File path
+   */
+  async deleteTestFile(filePath) {
+    try {
+      await fs.unlink(filePath);
+    } catch (error) {
+      // File might not exist, which is ok for delete operation
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Cleanup test artifacts
+   * @param {string} testFilePath - Test file path
+   * @param {Object} context - Test context
+   */
+  async cleanup(testFilePath, context) {
+    try {
+      // Delete the main test file
+      await this.deleteTestFile(testFilePath);
+      
+      // Clean up any additional test files that might have been created
+      await this.cleanupAdditionalFiles(context);
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.warn('Cleanup failed', {
+          testFilePath,
+          error: error.message
+        });
+      }
+    }
+  }
+
+  /**
+   * Clean up additional test files
+   * @param {Object} context - Test context
+   */
+  async cleanupAdditionalFiles(context) {
+    const timestamp = context.timestamp || Date.now();
+    const patterns = [
+      `test-requirement-${timestamp}.*`,
+      'test-requirement-*.txt',
+      'temp-verification-*.tmp',
+      'agent-test-*.log'
+    ];
+
+    for (const pattern of patterns) {
+      try {
+        const files = await fs.readdir(this.testDir);
+        const matchingFiles = files.filter(file => 
+          file.match(new RegExp(pattern.replace('*', '.*')))
+        );
+
+        for (const file of matchingFiles) {
+          const filePath = path.join(this.testDir, file);
+          await fs.unlink(filePath);
+        }
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  /**
+   * Check if directory is writable
+   * @param {string} dirPath - Directory path
+   * @returns {Promise<boolean>} - True if writable
+   */
+  async checkDirectoryWritable(dirPath) {
+    try {
+      const testFile = path.join(dirPath, '.write-test');
+      await fs.writeFile(testFile, 'test', 'utf8');
+      await fs.unlink(testFile);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get disk space information
+   * @param {string} dirPath - Directory path
+   * @returns {Promise<Object>} - Disk space info
+   */
+  async getDiskSpace(dirPath) {
+    try {
+      const stats = await fs.statfs(dirPath);
+      return {
+        total: stats.bsize * stats.blocks,
+        free: stats.bsize * stats.bavail,
+        available: stats.bsize * stats.bavail
+      };
+    } catch (error) {
+      return {
+        total: 0,
+        free: 0,
+        available: 0,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Test file permissions
+   * @param {string} filePath - File path
+   * @returns {Promise<Object>} - Permission test result
+   */
+  async testFilePermissions(filePath) {
+    try {
+      // Test read permission
+      await fs.access(filePath, fs.constants.R_OK);
+      
+      // Test write permission
+      const dirPath = path.dirname(filePath);
+      await fs.access(dirPath, fs.constants.W_OK);
+      
+      return {
+        readable: true,
+        writable: true,
+        executable: false
+      };
+    } catch (error) {
+      return {
+        readable: false,
+        writable: false,
+        executable: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get file operation verifier information
+   * @returns {Object} - Verifier info
+   */
+  getVerifierInfo() {
+    return {
+      ...this.getInfo(),
+      type: VerificationType.FILE_OPERATION,
+      supportedPlatforms: ['win32', 'darwin', 'linux'],
+      requirements: [
+        'file system access',
+        'write permissions',
+        'disk space'
+      ],
+      features: [
+        'file creation',
+        'file reading',
+        'file deletion',
+        'content verification',
+        'permission testing'
+      ],
+      limitations: [
+        'requires file system access',
+        'temporary files created',
+        'cleanup required',
+        'permission dependent'
+      ]
+    };
+  }
+
+  /**
+   * Create file operation verifier from configuration
+   * @param {Object} config - Configuration object
+   * @param {AgentLogger} logger - Logger instance
+   * @returns {FileOperationVerifier} - Verifier instance
+   */
+  static fromConfig(config, logger = null) {
+    return new FileOperationVerifier({
+      ...config,
+      logger
+    });
+  }
+
+  /**
+   * Create default file operation verifier
+   * @param {string} agentId - Agent identifier
+   * @param {AgentLogger} logger - Logger instance
+   * @returns {FileOperationVerifier} - Default verifier instance
+   */
+  static createDefault(agentId, logger = null) {
+    return new FileOperationVerifier({
+      id: `${agentId}-file-op`,
+      agentId,
+      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,
+      logger
+    });
+  }
+}
+
+module.exports = FileOperationVerifier;