vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/validation/report-generator.js

@@ -0,0 +1,136 @@
+/**
+ * Report Generator
+ * 
+ * Generates validation reports and recommendations.
+ */
+
+class ReportGenerator {
+  /**
+   * Generate test report
+   */
+  generateReport(validationResults, baseline, summary) {
+    return {
+      title: 'Test Validation Report',
+      generatedAt: new Date().toISOString(),
+      summary,
+      baseline,
+      validations: Array.from(validationResults.values()),
+      recommendations: this.generateRecommendations(summary)
+    };
+  }
+
+  /**
+   * Generate recommendations based on validation results
+   */
+  generateRecommendations(summary) {
+    const recommendations = [];
+    
+    if (summary.failed > 0) {
+      recommendations.push({
+        type: 'fix_failures',
+        priority: 'high',
+        title: `Fix ${summary.failed} Failed Validations`,
+        description: 'Some refactoring operations failed validation. Review errors and fix issues.',
+        action: 'Review validation errors and fix failing tests'
+      });
+    }
+    
+    if (summary.withRegressions > 0) {
+      recommendations.push({
+        type: 'address_regressions',
+        priority: 'critical',
+        title: `Address ${summary.withRegressions} Test Regressions`,
+        description: 'Test regressions were detected. Refactoring may have broken existing functionality.',
+        action: 'Review regression details and fix broken functionality'
+      });
+    }
+    
+    if (summary.averageDuration > 30) {
+      recommendations.push({
+        type: 'optimize_performance',
+        priority: 'medium',
+        title: 'Optimize Test Performance',
+        description: 'Test validation is taking longer than expected. Consider optimizing test suite.',
+        action: 'Review test performance and optimize slow tests'
+      });
+    }
+    
+    if (summary.errors.length > 0) {
+      recommendations.push({
+        type: 'fix_errors',
+        priority: 'high',
+        title: 'Fix Validation Errors',
+        description: 'Validation errors occurred during test execution.',
+        action: 'Review error messages and fix validation issues'
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Export validation results
+   */
+  exportResults(validationResults, baseline, options, format = 'json') {
+    const summary = this.calculateSummary(validationResults);
+    
+    const exportData = {
+      metadata: {
+        exportedAt: new Date().toISOString(),
+        validatorVersion: '1.0.0',
+        options
+      },
+      baseline,
+      validations: Array.from(validationResults.entries()).map(([id, validation]) => ({
+        operationId: id,
+        ...validation.getSummary()
+      })),
+      summary
+    };
+    
+    if (format === 'json') {
+      return JSON.stringify(exportData, null, 2);
+    }
+    
+    return exportData;
+  }
+
+  calculateSummary(validationResults) {
+    const summary = {
+      totalValidations: validationResults.size,
+      successful: 0,
+      failed: 0,
+      withRegressions: 0,
+      averageDuration: 0,
+      errors: [],
+      warnings: []
+    };
+    
+    let totalDuration = 0;
+    
+    for (const validation of validationResults.values()) {
+      if (validation.isSuccessful()) {
+        summary.successful++;
+      } else {
+        summary.failed++;
+      }
+      
+      if (validation.comparison?.hasRegressions) {
+        summary.withRegressions++;
+      }
+      
+      totalDuration += validation.duration;
+      summary.errors.push(...validation.errors);
+      summary.warnings.push(...validation.warnings);
+    }
+    
+    summary.averageDuration = summary.totalValidations > 0 ? 
+      totalDuration / summary.totalValidations : 0;
+    
+    return summary;
+  }
+}
+
+module.exports = {
+  ReportGenerator
+};

package/src/refactoring/validation/result-comparator.js

@@ -0,0 +1,92 @@
+/**
+ * Result Comparator
+ * 
+ * Compares validation results with baseline to detect regressions.
+ */
+
+class ResultComparator {
+  constructor(globalBaseline) {
+    this.globalBaseline = globalBaseline;
+  }
+
+  /**
+   * Compare validation results with baseline
+   */
+  compareWithBaseline(validationResults) {
+    if (!this.globalBaseline || !validationResults) {
+      return {
+        hasRegressions: false,
+        regressions: [],
+        improvements: [],
+        unchanged: []
+      };
+    }
+    
+    const comparison = {
+      hasRegressions: false,
+      regressions: [],
+      improvements: [],
+      unchanged: []
+    };
+    
+    // Compare overall results
+    const baselineTotal = this.globalBaseline.total || 0;
+    const validationTotal = validationResults.total || 0;
+    
+    if (validationTotal < baselineTotal) {
+      comparison.regressions.push({
+        type: 'missing_tests',
+        message: `${baselineTotal - validationTotal} tests are missing`,
+        severity: 'high'
+      });
+      comparison.hasRegressions = true;
+    }
+    
+    const baselineFailed = this.globalBaseline.failed || 0;
+    const validationFailed = validationResults.failed || 0;
+    
+    if (validationFailed > baselineFailed) {
+      comparison.regressions.push({
+        type: 'new_failures',
+        message: `${validationFailed - baselineFailed} new test failures`,
+        severity: 'critical'
+      });
+      comparison.hasRegressions = true;
+    }
+    
+    if (validationFailed < baselineFailed) {
+      comparison.improvements.push({
+        type: 'fixed_failures',
+        message: `${baselineFailed - validationFailed} test failures fixed`,
+        severity: 'good'
+      });
+    }
+    
+    // Compare individual test suites
+    for (const [suiteName, baselineSuite] of Object.entries(this.globalBaseline.suites || {})) {
+      const validationSuite = validationResults.suites?.[suiteName];
+      
+      if (validationSuite) {
+        if (validationSuite.failed > (baselineSuite.failed || 0)) {
+          comparison.regressions.push({
+            type: 'suite_regression',
+            message: `${suiteName} suite: ${validationSuite.failed} failures (baseline: ${baselineSuite.failed || 0})`,
+            severity: 'high',
+            suite: suiteName
+          });
+          comparison.hasRegressions = true;
+        }
+      }
+    }
+    
+    return comparison;
+  }
+
+  updateBaseline(baseline) {
+    this.globalBaseline = baseline;
+  }
+}
+
+module.exports = {
+  ResultComparator
+};

package/src/refactoring/validation/test-suite.js

@@ -0,0 +1,59 @@
+/**
+ * Test Suite
+ * 
+ * Represents a collection of tests that can be run together.
+ */
+
+const { TestRunner } = require('../../utils/test-runner');
+
+class TestSuite {
+  constructor(name, pattern, options = {}) {
+    this.name = name;
+    this.pattern = pattern;
+    this.options = {
+      timeout: 30000,
+      retries: 0,
+      parallel: true,
+      ...options
+    };
+    this.results = null;
+    this.lastRun = null;
+  }
+
+  async run() {
+    const testRunner = new TestRunner({
+      timeout: this.options.timeout,
+      retries: this.options.retries
+    });
+    
+    try {
+      this.results = await testRunner.runSpecificTests([this.pattern]);
+      this.lastRun = new Date().toISOString();
+      return this.results;
+    } catch (error) {
+      this.results = {
+        total: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        errors: [error],
+        duration: 0
+      };
+      this.lastRun = new Date().toISOString();
+      return this.results;
+    }
+  }
+
+  getSummary() {
+    return {
+      name: this.name,
+      pattern: this.pattern,
+      lastRun: this.lastRun,
+      results: this.results
+    };
+  }
+}
+
+module.exports = {
+  TestSuite
+};

package/src/refactoring/validation/test-validation-result.js

@@ -0,0 +1,83 @@
+/**
+ * Test Validation Result
+ * 
+ * Represents the result of a test validation operation.
+ */
+
+const { VALIDATION_STATUS } = require('./validation-status');
+
+class TestValidationResult {
+  constructor(operationId) {
+    this.operationId = operationId;
+    this.status = VALIDATION_STATUS.PENDING;
+    this.baselineResults = null;
+    this.validationResults = null;
+    this.comparison = null;
+    this.duration = 0;
+    this.errors = [];
+    this.warnings = [];
+    this.metadata = {
+      validatedAt: new Date().toISOString(),
+      testFramework: 'jest',
+      environment: process.env.NODE_ENV || 'test'
+    };
+  }
+
+  setStatus(status) {
+    this.status = status;
+  }
+
+  setBaselineResults(results) {
+    this.baselineResults = results;
+  }
+
+  setValidationResults(results) {
+    this.validationResults = results;
+  }
+
+  setComparison(comparison) {
+    this.comparison = comparison;
+  }
+
+  setDuration(duration) {
+    this.duration = duration;
+  }
+
+  addError(error) {
+    this.errors.push({
+      message: error.message,
+      timestamp: new Date().toISOString(),
+      stack: error.stack
+    });
+  }
+
+  addWarning(warning) {
+    this.warnings.push({
+      message: warning,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  isSuccessful() {
+    return this.status === VALIDATION_STATUS.PASSED && 
+           this.errors.length === 0 &&
+           (!this.comparison || !this.comparison.hasRegressions);
+  }
+
+  getSummary() {
+    return {
+      operationId: this.operationId,
+      status: this.status,
+      duration: this.duration,
+      baselineTests: this.baselineResults?.total || 0,
+      validationTests: this.validationResults?.total || 0,
+      hasRegressions: this.comparison?.hasRegressions || false,
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length
+    };
+  }
+}
+
+module.exports = {
+  TestValidationResult
+};

package/src/refactoring/validation/validation-runner.js

@@ -0,0 +1,95 @@
+/**
+ * Validation Runner
+ * 
+ * Handles running validation tests after refactoring operations.
+ */
+
+class ValidationRunner {
+  constructor(testSuites) {
+    this.testSuites = testSuites;
+  }
+
+  /**
+   * Run validation tests for affected files
+   */
+  async runValidationTests(affectedFiles) {
+    const results = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      duration: 0,
+      suites: {}
+    };
+    
+    const startTime = Date.now();
+    
+    try {
+      // Determine which test suites to run based on affected files
+      const relevantSuites = this.getRelevantTestSuites(affectedFiles);
+      
+      for (const suiteName of relevantSuites) {
+        const suite = this.testSuites.get(suiteName);
+        if (suite) {
+          console.log(`Running ${suiteName} validation tests...`);
+          
+          const suiteResults = await suite.run();
+          results.suites[suiteName] = suiteResults;
+          
+          results.total += suiteResults.total || 0;
+          results.passed += suiteResults.passed || 0;
+          results.failed += suiteResults.failed || 0;
+          results.skipped += suiteResults.skipped || 0;
+        }
+      }
+      
+      results.duration = (Date.now() - startTime) / 1000;
+      
+      console.log(`Validation completed: ${results.passed}/${results.total} passed`);
+      
+      return results;
+      
+    } catch (error) {
+      console.error('Validation test execution failed:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Get relevant test suites for affected files
+   */
+  getRelevantTestSuites(affectedFiles) {
+    const relevantSuites = new Set();
+    
+    for (const filePath of affectedFiles) {
+      // Check if file is a test file
+      if (filePath.includes('.test.') || filePath.includes('.spec.')) {
+        relevantSuites.add('unit');
+        continue;
+      }
+      
+      // Check file path to determine relevant suites
+      if (filePath.includes('/test/') || filePath.includes('/tests/')) {
+        relevantSuites.add('unit');
+      }
+      
+      if (filePath.includes('/integration/')) {
+        relevantSuites.add('integration');
+      }
+      
+      if (filePath.includes('/e2e/')) {
+        relevantSuites.add('e2e');
+      }
+      
+      // For refactoring operations, always run unit and refactoring tests
+      relevantSuites.add('unit');
+      relevantSuites.add('refactoring');
+    }
+    
+    return Array.from(relevantSuites);
+  }
+}
+
+module.exports = {
+  ValidationRunner
+};

package/src/refactoring/validation/validation-status.js

@@ -0,0 +1,18 @@
+/**
+ * Validation Status Constants
+ * 
+ * Defines the possible states of a validation operation.
+ */
+
+const VALIDATION_STATUS = {
+  PENDING: 'pending',
+  RUNNING: 'running',
+  PASSED: 'passed',
+  FAILED: 'failed',
+  SKIPPED: 'skipped',
+  ERROR: 'error'
+};
+
+module.exports = {
+  VALIDATION_STATUS
+};