vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/refactoring/functionality-validator.js

@@ -0,0 +1,816 @@
+/**
+ * Functionality Preservation Validator
+ * 
+ * Validates that refactoring operations preserve original functionality.
+ * Uses multiple validation techniques to ensure behavioral consistency.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Validation techniques
+ */
+const VALIDATION_TECHNIQUES = {
+  STATIC_ANALYSIS: 'static_analysis',
+  BEHAVIORAL_COMPARISON: 'behavioral_comparison',
+  API_COMPATIBILITY: 'api_compatibility',
+  TYPE_CHECKING: 'type_checking',
+  RUNTIME_VALIDATION: 'runtime_validation'
+};
+
+/**
+ * Validation severity levels
+ */
+const VALIDATION_SEVERITY = {
+  INFO: 'info',
+  WARNING: 'warning',
+  ERROR: 'error',
+  CRITICAL: 'critical'
+};
+
+/**
+ * Functionality validation result class
+ */
+class FunctionalityValidationResult {
+  constructor(operationId) {
+    this.operationId = operationId;
+    this.techniques = new Map();
+    this.success = false;
+    this.confidence = 0;
+    this.issues = [];
+    this.metadata = {
+      validatedAt: new Date().toISOString(),
+      duration: 0,
+      environment: process.env.NODE_ENV || 'development'
+    };
+  }
+
+  addTechniqueResult(technique, result) {
+    this.techniques.set(technique, result);
+  }
+
+  addIssue(severity, message, details = null) {
+    this.issues.push({
+      severity,
+      message,
+      details,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  setSuccess(success) {
+    this.success = success;
+  }
+
+  setConfidence(confidence) {
+    this.confidence = Math.max(0, Math.min(1, confidence));
+  }
+
+  calculateOverallSuccess() {
+    const techniqueResults = Array.from(this.techniques.values());
+    const passedTechniques = techniqueResults.filter(r => r.success).length;
+    const totalTechniques = techniqueResults.length;
+    
+    if (totalTechniques === 0) {
+      this.setSuccess(false);
+      this.setConfidence(0);
+      return;
+    }
+    
+    const successRate = passedTechniques / totalTechniques;
+    this.setSuccess(successRate >= 0.8 && this.issues.filter(i => i.severity === VALIDATION_SEVERITY.ERROR || i.severity === VALIDATION_SEVERITY.CRITICAL).length === 0);
+    this.setConfidence(successRate);
+  }
+
+  getSummary() {
+    this.calculateOverallSuccess();
+    
+    return {
+      operationId: this.operationId,
+      success: this.success,
+      confidence: this.confidence,
+      techniques: Array.from(this.techniques.entries()).map(([tech, result]) => ({
+        technique: tech,
+        success: result.success,
+        duration: result.duration || 0,
+        issues: result.issues || []
+      })),
+      issues: this.issues,
+      issueCount: this.issues.length,
+      criticalIssues: this.issues.filter(i => i.severity === VALIDATION_SEVERITY.CRITICAL).length,
+      errorIssues: this.issues.filter(i => i.severity === VALIDATION_SEVERITY.ERROR).length
+    };
+  }
+}
+
+/**
+ * Technique result class
+ */
+class TechniqueResult {
+  constructor(technique) {
+    this.technique = technique;
+    this.success = false;
+    this.duration = 0;
+    this.issues = [];
+    this.metadata = {
+      executedAt: new Date().toISOString(),
+      details: {}
+    };
+  }
+
+  setSuccess(success) {
+    this.success = success;
+  }
+
+  setDuration(duration) {
+    this.duration = duration;
+  }
+
+  addIssue(severity, message, details = null) {
+    this.issues.push({
+      severity,
+      message,
+      details,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  setDetails(details) {
+    this.metadata.details = details;
+  }
+}
+
+/**
+ * Functionality validator class
+ */
+class FunctionalityValidator {
+  constructor(options = {}) {
+    this.options = {
+      enableStaticAnalysis: true,
+      enableBehavioralComparison: true,
+      enableAPICompatibility: true,
+      enableTypeChecking: true,
+      enableRuntimeValidation: true,
+      strictMode: false,
+      ...options
+    };
+    
+    this.validationResults = new Map();
+  }
+
+  /**
+   * Validate functionality preservation for a refactoring operation
+   */
+  async validateOperation(operationId, originalPath, modifiedPath, options = {}) {
+    const result = new FunctionalityValidationResult(operationId);
+    const startTime = Date.now();
+    
+    try {
+      console.log(`Validating functionality preservation for: ${operationId}`);
+      
+      // Static analysis
+      if (this.options.enableStaticAnalysis) {
+        await this.validateStaticAnalysis(originalPath, modifiedPath, result);
+      }
+      
+      // Behavioral comparison
+      if (this.options.enableBehavioralComparison) {
+        await this.validateBehavioralComparison(originalPath, modifiedPath, result);
+      }
+      
+      // API compatibility
+      if (this.options.enableAPICompatibility) {
+        await this.validateAPICompatibility(originalPath, modifiedPath, result);
+      }
+      
+      // Type checking
+      if (this.options.enableTypeChecking) {
+        await this.validateTypeChecking(originalPath, modifiedPath, result);
+      }
+      
+      // Runtime validation
+      if (this.options.enableRuntimeValidation) {
+        await this.validateRuntime(originalPath, modifiedPath, result);
+      }
+      
+      result.calculateOverallSuccess();
+      result.metadata.duration = (Date.now() - startTime) / 1000;
+      
+      console.log(`Validation completed: ${result.success ? 'PASSED' : 'FAILED'} (confidence: ${(result.confidence * 100).toFixed(1)}%)`);
+      
+    } catch (error) {
+      result.addIssue(VALIDATION_SEVERITY.ERROR, 'Validation execution failed', error.message);
+      result.setSuccess(false);
+      result.metadata.duration = (Date.now() - startTime) / 1000;
+    }
+    
+    this.validationResults.set(operationId, result);
+    return result;
+  }
+
+  /**
+   * Perform static analysis validation
+   */
+  async validateStaticAnalysis(originalPath, modifiedPath, result) {
+    const techniqueResult = new TechniqueResult(VALIDATION_TECHNIQUES.STATIC_ANALYSIS);
+    const startTime = Date.now();
+    
+    try {
+      console.log('Performing static analysis validation...');
+      
+      // Compare AST structures
+      const astComparison = await this.compareASTs(originalPath, modifiedPath);
+      techniqueResult.setDetails({ astComparison });
+      
+      if (!astComparison.structuralChangesAcceptable) {
+        techniqueResult.addIssue(VALIDATION_SEVERITY.WARNING, 'Significant structural changes detected', astComparison);
+      }
+      
+      // Check for missing exports
+      const exportComparison = await this.compareExports(originalPath, modifiedPath);
+      techniqueResult.metadata.details.exportComparison = exportComparison;
+      
+      if (exportComparison.missingExports.length > 0) {
+        techniqueResult.addIssue(
+          VALIDATION_SEVERITY.ERROR,
+          'Missing exports detected',
+          { missing: exportComparison.missingExports }
+        );
+      }
+      
+      // Check for breaking changes
+      const breakingChanges = await this.detectBreakingChanges(originalPath, modifiedPath);
+      techniqueResult.metadata.details.breakingChanges = breakingChanges;
+      
+      if (breakingChanges.length > 0) {
+        techniqueResult.addIssue(
+          VALIDATION_SEVERITY.ERROR,
+          'Breaking changes detected',
+          { changes: breakingChanges }
+        );
+      }
+      
+      techniqueResult.setSuccess(techniqueResult.issues.filter(i => i.severity === VALIDATION_SEVERITY.ERROR || i.severity === VALIDATION_SEVERITY.CRITICAL).length === 0);
+      
+    } catch (error) {
+      techniqueResult.addIssue(VALIDATION_SEVERITY.ERROR, 'Static analysis failed', error.message);
+      techniqueResult.setSuccess(false);
+    }
+    
+    techniqueResult.setDuration((Date.now() - startTime) / 1000);
+    result.addTechniqueResult(VALIDATION_TECHNIQUES.STATIC_ANALYSIS, techniqueResult);
+  }
+
+  /**
+   * Perform behavioral comparison validation
+   */
+  async validateBehavioralComparison(originalPath, modifiedPath, result) {
+    const techniqueResult = new TechniqueResult(VALIDATION_TECHNIQUES.BEHAVIORAL_COMPARISON);
+    const startTime = Date.now();
+    
+    try {
+      console.log('Performing behavioral comparison...');
+      
+      // Create test scenarios
+      const scenarios = await this.generateTestScenarios(originalPath);
+      techniqueResult.metadata.details.scenarios = scenarios;
+      
+      // Execute scenarios on both versions
+      const originalResults = await this.executeScenarios(originalPath, scenarios);
+      const modifiedResults = await this.executeScenarios(modifiedPath, scenarios);
+      
+      // Compare results
+      const comparison = this.compareScenarioResults(originalResults, modifiedResults);
+      techniqueResult.metadata.details.behavioralComparison = comparison;
+      
+      if (comparison.differences.length > 0) {
+        techniqueResult.addIssue(
+          VALIDATION_SEVERITY.ERROR,
+          'Behavioral differences detected',
+          { differences: comparison.differences }
+        );
+      }
+      
+      techniqueResult.setSuccess(comparison.differences.length === 0);
+      
+    } catch (error) {
+      techniqueResult.addIssue(VALIDATION_SEVERITY.ERROR, 'Behavioral comparison failed', error.message);
+      techniqueResult.setSuccess(false);
+    }
+    
+    techniqueResult.setDuration((Date.now() - startTime) / 1000);
+    result.addTechniqueResult(VALIDATION_TECHNIQUES.BEHAVIORAL_COMPARISON, techniqueResult);
+  }
+
+  /**
+   * Perform API compatibility validation
+   */
+  async validateAPICompatibility(originalPath, modifiedPath, result) {
+    const techniqueResult = new TechniqueResult(VALIDATION_TECHNIQUES.API_COMPATIBILITY);
+    const startTime = Date.now();
+    
+    try {
+      console.log('Performing API compatibility validation...');
+      
+      // Extract API signatures
+      const originalAPI = await this.extractAPI(originalPath);
+      const modifiedAPI = await this.extractAPI(modifiedPath);
+      
+      techniqueResult.metadata.details.originalAPI = originalAPI;
+      techniqueResult.metadata.details.modifiedAPI = modifiedAPI;
+      
+      // Compare APIs
+      const apiComparison = this.compareAPIs(originalAPI, modifiedAPI);
+      techniqueResult.metadata.details.apiComparison = apiComparison;
+      
+      if (apiComparison.removedMethods.length > 0) {
+        techniqueResult.addIssue(
+          VALIDATION_SEVERITY.ERROR,
+          'API methods removed',
+          { removed: apiComparison.removedMethods }
+        );
+      }
+      
+      if (apiComparison.changedSignatures.length > 0) {
+        techniqueResult.addIssue(
+          VALIDATION_SEVERITY.WARNING,
+          'API signatures changed',
+          { changed: apiComparison.changedSignatures }
+        );
+      }
+      
+      techniqueResult.setSuccess(apiCompatibilityAcceptable(apiComparison, this.options.strictMode));
+      
+    } catch (error) {
+      techniqueResult.addIssue(VALIDATION_SEVERITY.ERROR, 'API compatibility check failed', error.message);
+      techniqueResult.setSuccess(false);
+    }
+    
+    techniqueResult.setDuration((Date.now() - startTime) / 1000);
+    result.addTechniqueResult(VALIDATION_TECHNIQUES.API_COMPATIBILITY, techniqueResult);
+  }
+
+  /**
+   * Perform type checking validation
+   */
+  async validateTypeChecking(originalPath, modifiedPath, result) {
+    const techniqueResult = new TechniqueResult(VALIDATION_TECHNIQUES.TYPE_CHECKING);
+    const startTime = Date.now();
+    
+    try {
+      console.log('Performing type checking...');
+      
+      // Run TypeScript compiler if applicable
+      const isTypeScript = originalPath.endsWith('.ts') || originalPath.endsWith('.tsx');
+      
+      if (isTypeScript) {
+        const originalTypeErrors = await this.runTypeChecker(originalPath);
+        const modifiedTypeErrors = await this.runTypeChecker(modifiedPath);
+        
+        techniqueResult.metadata.details.originalTypeErrors = originalTypeErrors;
+        techniqueResult.metadata.details.modifiedTypeErrors = modifiedTypeErrors;
+        
+        if (modifiedTypeErrors.length > originalTypeErrors.length) {
+          techniqueResult.addIssue(
+            VALIDATION_SEVERITY.ERROR,
+            'New type errors introduced',
+            { newErrors: modifiedTypeErrors.length - originalTypeErrors.length }
+          );
+        }
+        
+        techniqueResult.setSuccess(modifiedTypeErrors.length <= originalTypeErrors.length);
+      } else {
+        // For JavaScript, use JSDoc validation or skip
+        techniqueResult.setSuccess(true);
+        techniqueResult.addIssue(VALIDATION_SEVERITY.INFO, 'Type checking skipped for JavaScript file');
+      }
+      
+    } catch (error) {
+      techniqueResult.addIssue(VALIDATION_SEVERITY.ERROR, 'Type checking failed', error.message);
+      techniqueResult.setSuccess(false);
+    }
+    
+    techniqueResult.setDuration((Date.now() - startTime) / 1000);
+    result.addTechniqueResult(VALIDATION_TECHNIQUES.TYPE_CHECKING, techniqueResult);
+  }
+
+  /**
+   * Perform runtime validation
+   */
+  async validateRuntime(originalPath, modifiedPath, result) {
+    const techniqueResult = new TechniqueResult(VALIDATION_TECHNIQUES.RUNTIME_VALIDATION);
+    const startTime = Date.now();
+    
+    try {
+      console.log('Performing runtime validation...');
+      
+      // Load and execute both modules
+      const originalModule = await this.loadModule(originalPath);
+      const modifiedModule = await this.loadModule(modifiedPath);
+      
+      // Test module interfaces
+      const interfaceTest = await this.testModuleInterface(originalModule, modifiedModule);
+      techniqueResult.metadata.details.interfaceTest = interfaceTest;
+      
+      if (!interfaceTest.compatible) {
+        techniqueResult.addIssue(
+          VALIDATION_SEVERITY.ERROR,
+          'Module interface incompatibility',
+          interfaceTest
+        );
+      }
+      
+      techniqueResult.setSuccess(interfaceTest.compatible);
+      
+    } catch (error) {
+      techniqueResult.addIssue(VALIDATION_SEVERITY.ERROR, 'Runtime validation failed', error.message);
+      techniqueResult.setSuccess(false);
+    }
+    
+    techniqueResult.setDuration((Date.now() - startTime) / 1000);
+    result.addTechniqueResult(VALIDATION_TECHNIQUES.RUNTIME_VALIDATION, techniqueResult);
+  }
+
+  /**
+   * Compare AST structures
+   */
+  async compareASTs(originalPath, modifiedPath) {
+    // Simplified AST comparison
+    const originalContent = fs.readFileSync(originalPath, 'utf8');
+    const modifiedContent = fs.readFileSync(modifiedPath, 'utf8');
+    
+    const originalLines = originalContent.split('\n').length;
+    const modifiedLines = modifiedContent.split('\n').length;
+    
+    return {
+      structuralChangesAcceptable: Math.abs(originalLines - modifiedLines) < originalLines * 0.5,
+      originalLines,
+      modifiedLines,
+      lineDifference: modifiedLines - originalLines
+    };
+  }
+
+  /**
+   * Compare exports
+   */
+  async compareExports(originalPath, modifiedPath) {
+    const originalExports = await this.extractExports(originalPath);
+    const modifiedExports = await this.extractExports(modifiedPath);
+    
+    const missingExports = originalExports.filter(exp => !modifiedExports.includes(exp));
+    const newExports = modifiedExports.filter(exp => !originalExports.includes(exp));
+    
+    return {
+      originalExports,
+      modifiedExports,
+      missingExports,
+      newExports
+    };
+  }
+
+  /**
+   * Detect breaking changes
+   */
+  async detectBreakingChanges(originalPath, modifiedPath) {
+    // Simplified breaking change detection
+    const changes = [];
+    
+    // Check for removed functions
+    const originalFunctions = await this.extractFunctions(originalPath);
+    const modifiedFunctions = await this.extractFunctions(modifiedPath);
+    
+    for (const func of originalFunctions) {
+      if (!modifiedFunctions.includes(func)) {
+        changes.push({
+          type: 'removed_function',
+          name: func,
+          severity: 'breaking'
+        });
+      }
+    }
+    
+    return changes;
+  }
+
+  /**
+   * Generate test scenarios
+   */
+  async generateTestScenarios(filePath) {
+    // Simplified scenario generation
+    return [
+      {
+        name: 'module_load',
+        type: 'load',
+        description: 'Test module loading'
+      },
+      {
+        name: 'export_access',
+        type: 'access',
+        description: 'Test export access'
+      }
+    ];
+  }
+
+  /**
+   * Execute test scenarios
+   */
+  async executeScenarios(filePath, scenarios) {
+    const results = [];
+    
+    for (const scenario of scenarios) {
+      try {
+        const result = await this.executeScenario(filePath, scenario);
+        results.push(result);
+      } catch (error) {
+        results.push({
+          scenario: scenario.name,
+          success: false,
+          error: error.message
+        });
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Execute single scenario
+   */
+  async executeScenario(filePath, scenario) {
+    switch (scenario.type) {
+      case 'load':
+        const module = await this.loadModule(filePath);
+        return { scenario: scenario.name, success: true, result: 'loaded' };
+      case 'access':
+        const mod = await this.loadModule(filePath);
+        return { scenario: scenario.name, success: true, result: Object.keys(mod) };
+      default:
+        return { scenario: scenario.name, success: false, error: 'Unknown scenario type' };
+    }
+  }
+
+  /**
+   * Compare scenario results
+   */
+  compareScenarioResults(originalResults, modifiedResults) {
+    const differences = [];
+    
+    for (let i = 0; i < Math.min(originalResults.length, modifiedResults.length); i++) {
+      const original = originalResults[i];
+      const modified = modifiedResults[i];
+      
+      if (original.success !== modified.success) {
+        differences.push({
+          scenario: original.scenario,
+          type: 'success_mismatch',
+          original: original.success,
+          modified: modified.success
+        });
+      }
+      
+      if (JSON.stringify(original.result) !== JSON.stringify(modified.result)) {
+        differences.push({
+          scenario: original.scenario,
+          type: 'result_mismatch',
+          original: original.result,
+          modified: modified.result
+        });
+      }
+    }
+    
+    return { differences };
+  }
+
+  /**
+   * Extract API from file
+   */
+  async extractAPI(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const api = {
+      functions: [],
+      classes: [],
+      exports: [],
+      imports: []
+    };
+    
+    // Simple extraction using regex
+    const functionMatches = content.match(/(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:function|\([^)]*\)\s*=>))/g);
+    if (functionMatches) {
+      for (const match of functionMatches) {
+        const nameMatch = match.match(/(\w+)/);
+        if (nameMatch) {
+          api.functions.push(nameMatch[1]);
+        }
+      }
+    }
+    
+    const classMatches = content.match(/class\s+(\w+)/g);
+    if (classMatches) {
+      for (const match of classMatches) {
+        const nameMatch = match.match(/class\s+(\w+)/);
+        if (nameMatch) {
+          api.classes.push(nameMatch[1]);
+        }
+      }
+    }
+    
+    return api;
+  }
+
+  /**
+   * Compare APIs
+   */
+  compareAPIs(originalAPI, modifiedAPI) {
+    const removedMethods = originalAPI.functions.filter(f => !modifiedAPI.functions.includes(f));
+    const newMethods = modifiedAPI.functions.filter(f => !originalAPI.functions.includes(f));
+    const changedSignatures = []; // Simplified - would need signature analysis
+    
+    return {
+      removedMethods,
+      newMethods,
+      changedSignatures
+    };
+  }
+
+  /**
+   * Check API compatibility acceptability
+   */
+  apiCompatibilityAcceptable(comparison, strictMode) {
+    if (strictMode) {
+      return comparison.removedMethods.length === 0 && comparison.changedSignatures.length === 0;
+    }
+    
+    // Allow additions but not removals in non-strict mode
+    return comparison.removedMethods.length === 0;
+  }
+
+  /**
+   * Run type checker
+   */
+  async runTypeChecker(filePath) {
+    try {
+      // Try to run TypeScript compiler
+      const result = execSync(`npx tsc --noEmit ${filePath}`, { encoding: 'utf8' });
+      return []; // No errors
+    } catch (error) {
+      // Parse TypeScript errors
+      const errorOutput = error.stdout || error.message;
+      const errors = errorOutput.split('\n').filter(line => line.trim()).map(line => ({
+        line: line,
+        message: line
+      }));
+      return errors;
+    }
+  }
+
+  /**
+   * Load module safely
+   */
+  async loadModule(filePath) {
+    // Clear require cache to ensure fresh load
+    delete require.cache[require.resolve(filePath)];
+    return require(filePath);
+  }
+
+  /**
+   * Test module interface compatibility
+   */
+  async testModuleInterface(originalModule, modifiedModule) {
+    const originalKeys = new Set(Object.keys(originalModule));
+    const modifiedKeys = new Set(Object.keys(modifiedModule));
+    
+    const missingKeys = Array.from(originalKeys).filter(key => !modifiedKeys.has(key));
+    const extraKeys = Array.from(modifiedKeys).filter(key => !originalKeys.has(key));
+    
+    return {
+      compatible: missingKeys.length === 0,
+      missingKeys,
+      extraKeys
+    };
+  }
+
+  /**
+   * Helper methods for extraction
+   */
+  async extractExports(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const exports = [];
+    
+    const exportMatches = content.match(/export\s+(?:default\s+)?(?:function|class|const|let|var)\s+(\w+)/g);
+    if (exportMatches) {
+      for (const match of exportMatches) {
+        const nameMatch = match.match(/\w+/);
+        if (nameMatch) {
+          exports.push(nameMatch[0]);
+        }
+      }
+    }
+    
+    return exports;
+  }
+
+  async extractFunctions(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const functions = [];
+    
+    const functionMatches = content.match(/(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:function|\([^)]*\)\s*=>))/g);
+    if (functionMatches) {
+      for (const match of functionMatches) {
+        const nameMatch = match.match(/(\w+)/);
+        if (nameMatch) {
+          functions.push(nameMatch[1]);
+        }
+      }
+    }
+    
+    return functions;
+  }
+
+  /**
+   * Get validation summary
+   */
+  getValidationSummary() {
+    const summary = {
+      totalValidations: this.validationResults.size,
+      successful: 0,
+      failed: 0,
+      averageConfidence: 0,
+      techniqueUsage: {},
+      commonIssues: {}
+    };
+    
+    let totalConfidence = 0;
+    const techniqueCounts = {};
+    const issueCounts = {};
+    
+    for (const result of this.validationResults.values()) {
+      if (result.success) {
+        summary.successful++;
+      } else {
+        summary.failed++;
+      }
+      
+      totalConfidence += result.confidence;
+      
+      // Count technique usage
+      for (const [technique, techniqueResult] of result.techniques) {
+        techniqueCounts[technique] = (techniqueCounts[technique] || 0) + 1;
+      }
+      
+      // Count issues
+      for (const issue of result.issues) {
+        const key = `${issue.severity}_${issue.message.substring(0, 50)}`;
+        issueCounts[key] = (issueCounts[key] || 0) + 1;
+      }
+    }
+    
+    summary.averageConfidence = summary.totalValidations > 0 ? 
+      totalConfidence / summary.totalValidations : 0;
+    summary.techniqueUsage = techniqueCounts;
+    summary.commonIssues = issueCounts;
+    
+    return summary;
+  }
+
+  /**
+   * Export validation results
+   */
+  exportResults(format = 'json') {
+    const exportData = {
+      metadata: {
+        exportedAt: new Date().toISOString(),
+        validatorVersion: '1.0.0',
+        options: this.options
+      },
+      summary: this.getValidationSummary(),
+      validations: Array.from(this.validationResults.entries()).map(([id, result]) => ({
+        operationId: id,
+        ...result.getSummary()
+      }))
+    };
+    
+    if (format === 'json') {
+      return JSON.stringify(exportData, null, 2);
+    }
+    
+    return exportData;
+  }
+}
+
+function apiCompatibilityAcceptable(comparison, strictMode) {
+  if (strictMode) {
+    return comparison.removedMethods.length === 0 && comparison.changedSignatures.length === 0;
+  }
+  
+  return comparison.removedMethods.length === 0;
+}
+
+module.exports = {
+  FunctionalityValidator,
+  FunctionalityValidationResult,
+  TechniqueResult,
+  VALIDATION_TECHNIQUES,
+  VALIDATION_SEVERITY
+};