vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/utils/test-parser.js

@@ -0,0 +1,215 @@
+/**
+ * Test Parser
+ * 
+ * Parses test output from various test frameworks.
+ */
+
+/**
+ * Parse test output (Jest JSON format)
+ */
+function parseTestOutput(stdout, stderr, exitCode, duration) {
+  try {
+    // Try to parse JSON output
+    const jsonMatch = stdout.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const jsonData = JSON.parse(jsonMatch[0]);
+      return parseJestResults(jsonData, duration);
+    }
+  } catch (error) {
+    // JSON parsing failed, fall back to basic parsing
+  }
+
+  return parseBasicOutput(stdout, stderr, exitCode, duration);
+}
+
+/**
+ * Parse Jest results
+ */
+function parseJestResults(jsonData, duration) {
+  const results = {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    errors: 0,
+    duration,
+    suites: [],
+    tests: [],
+    coverage: null
+  };
+
+  if (jsonData.numTotalTests) {
+    results.total = jsonData.numTotalTests;
+    results.passed = jsonData.numPassedTests || 0;
+    results.failed = jsonData.numFailedTests || 0;
+    results.skipped = jsonData.numPendingTests || 0;
+  }
+
+  if (jsonData.testResults) {
+    for (const testSuite of jsonData.testResults) {
+      const suite = {
+        name: testSuite.name,
+        file: testSuite.testFilePath,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        duration: testSuite.perfStats?.end || 0,
+        tests: []
+      };
+
+      if (testSuite.assertionResults) {
+        for (const test of testSuite.assertionResults) {
+          const testResult = {
+            title: test.title,
+            fullName: test.fullName,
+            status: test.status,
+            duration: test.duration || 0,
+            failureMessages: test.failureMessages || []
+          };
+
+          suite.tests.push(testResult);
+          results.tests.push(testResult);
+
+          switch (test.status) {
+            case 'passed':
+              suite.passed++;
+              break;
+            case 'failed':
+              suite.failed++;
+              break;
+            case 'pending':
+              suite.skipped++;
+              break;
+          }
+        }
+      }
+
+      results.suites.push(suite);
+    }
+  }
+
+  if (jsonData.coverageMap) {
+    results.coverage = parseCoverageData(jsonData.coverageMap);
+  }
+
+  return results;
+}
+
+/**
+ * Parse basic test output
+ */
+function parseBasicOutput(stdout, stderr, exitCode, duration) {
+  const results = {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    errors: 0,
+    duration,
+    suites: [],
+    tests: [],
+    coverage: null
+  };
+
+  // Parse Jest-style output
+  const testMatch = stdout.match(/(\d+)\s+tests?\s+(\d+)\s+failed/);
+  if (testMatch) {
+    results.total = parseInt(testMatch[1]);
+    results.failed = parseInt(testMatch[2]);
+    results.passed = results.total - results.failed;
+  }
+
+  // Parse pass/fail summary
+  const passMatch = stdout.match(/(\d+)\s+passing/);
+  if (passMatch) {
+    results.passed = parseInt(passMatch[1]);
+  }
+
+  const failMatch = stdout.match(/(\d+)\s+failing/);
+  if (failMatch) {
+    results.failed = parseInt(failMatch[1]);
+  }
+
+  const skipMatch = stdout.match(/(\d+)\s+skipping/);
+  if (skipMatch) {
+    results.skipped = parseInt(skipMatch[1]);
+  }
+
+  // Extract individual test results
+  const testLines = stdout.split('\n');
+  for (const line of testLines) {
+    const testMatch = line.match(/^(✓|✗|○)\s+(.+)$/);
+    if (testMatch) {
+      const status = testMatch[1] === '✓' ? 'passed' : 
+                    testMatch[1] === '✗' ? 'failed' : 'skipped';
+      const title = testMatch[2];
+      
+      results.tests.push({
+        title,
+        status,
+        duration: 0,
+        failureMessages: status === 'failed' ? [line] : []
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Parse coverage data
+ */
+function parseCoverageData(coverageMap) {
+  const coverage = {
+    lines: { total: 0, covered: 0, percentage: 0 },
+    functions: { total: 0, covered: 0, percentage: 0 },
+    branches: { total: 0, covered: 0, percentage: 0 },
+    statements: { total: 0, covered: 0, percentage: 0 }
+  };
+
+  for (const [filePath, fileCoverage] of Object.entries(coverageMap)) {
+    // Parse line coverage
+    if (fileCoverage.l) {
+      const lines = Object.values(fileCoverage.l);
+      coverage.lines.total += lines.length;
+      coverage.lines.covered += lines.filter(count => count > 0).length;
+    }
+
+    // Parse function coverage
+    if (fileCoverage.f) {
+      const functions = Object.values(fileCoverage.f);
+      coverage.functions.total += functions.length;
+      coverage.functions.covered += functions.filter(count => count > 0).length;
+    }
+
+    // Parse branch coverage
+    if (fileCoverage.b) {
+      for (const branches of Object.values(fileCoverage.b)) {
+        coverage.branches.total += branches.length;
+        coverage.branches.covered += branches.filter(count => count > 0).length;
+      }
+    }
+
+    // Parse statement coverage
+    if (fileCoverage.s) {
+      const statements = Object.values(fileCoverage.s);
+      coverage.statements.total += statements.length;
+      coverage.statements.covered += statements.filter(count => count > 0).length;
+    }
+  }
+
+  // Calculate percentages
+  for (const metric of Object.values(coverage)) {
+    metric.percentage = metric.total > 0 ? 
+      Math.round((metric.covered / metric.total) * 100) : 0;
+  }
+
+  return coverage;
+}
+
+module.exports = {
+  parseTestOutput,
+  parseJestResults,
+  parseBasicOutput,
+  parseCoverageData
+};

package/src/utils/test-runner-baseline.js

@@ -0,0 +1,63 @@
+/**
+ * Test Runner Baseline Operations
+ * 
+ * Handles baseline test execution before refactoring.
+ */
+
+const { executeTests } = require('./test-executor');
+const { parseTestOutput, parseBasicOutput } = require('./test-parser');
+
+/**
+ * Execute tests and collect results
+ */
+async function executeTestsAndCollect(options = {}) {
+  const executionResult = await executeTests({
+    verbose: options.verbose || false,
+    timeout: options.timeout || 300000
+  });
+  
+  try {
+    const results = parseTestOutput(
+      executionResult.stdout,
+      executionResult.stderr,
+      executionResult.exitCode,
+      executionResult.duration
+    );
+    return results;
+  } catch (parseError) {
+    // Fallback to basic parsing
+    const fallbackResults = parseBasicOutput(
+      executionResult.stdout,
+      executionResult.stderr,
+      executionResult.exitCode,
+      executionResult.duration
+    );
+    return fallbackResults;
+  }
+}
+
+/**
+ * Run baseline tests before refactoring
+ */
+async function runBaseline(runner) {
+  console.log('Running baseline tests...');
+  
+  try {
+    const results = await executeTestsAndCollect({
+      verbose: runner.options.verbose,
+      timeout: runner.options.timeout
+    });
+    
+    runner.setBaselineResults(results);
+    
+    console.log(`Baseline completed: ${results.passed}/${results.total} passed`);
+    return results;
+  } catch (error) {
+    throw new Error(`Baseline test execution failed: ${error.message}`);
+  }
+}
+
+module.exports = {
+  runBaseline,
+  executeTestsAndCollect
+};

package/src/utils/test-runner-core.js

@@ -0,0 +1,98 @@
+/**
+ * Core Test Runner
+ * 
+ * Base class for test runner operations.
+ */
+
+const { checkTestAvailability, getTestConfig } = require('./test-config');
+
+/**
+ * Test result types
+ */
+const TEST_RESULT_TYPES = {
+  PASS: 'pass',
+  FAIL: 'fail',
+  SKIP: 'skip',
+  ERROR: 'error'
+};
+
+/**
+ * Core test runner class
+ */
+class TestRunnerCore {
+  constructor(options = {}) {
+    this.options = {
+      testCommand: 'npm test',
+      testDir: 'tests',
+      timeout: 300000, // 5 minutes
+      retries: 0,
+      verbose: false,
+      ...options
+    };
+    
+    this.baselineResults = null;
+    this.currentResults = null;
+    this.regressionDetected = false;
+  }
+
+  /**
+   * Check if tests are available
+   */
+  checkTestAvailability() {
+    return checkTestAvailability();
+  }
+
+  /**
+   * Get test configuration
+   */
+  getTestConfig() {
+    return getTestConfig();
+  }
+
+  /**
+   * Get current baseline results
+   */
+  getBaselineResults() {
+    return this.baselineResults;
+  }
+
+  /**
+   * Get current test results
+   */
+  getCurrentResults() {
+    return this.currentResults;
+  }
+
+  /**
+   * Check if regressions were detected
+   */
+  hasRegressions() {
+    return this.regressionDetected;
+  }
+
+  /**
+   * Set baseline results
+   */
+  setBaselineResults(results) {
+    this.baselineResults = results;
+  }
+
+  /**
+   * Set current results
+   */
+  setCurrentResults(results) {
+    this.currentResults = results;
+  }
+
+  /**
+   * Set regression detection flag
+   */
+  setRegressionDetected(detected) {
+    this.regressionDetected = detected;
+  }
+}
+
+module.exports = {
+  TestRunnerCore,
+  TEST_RESULT_TYPES
+};

package/src/utils/test-runner-report.js

@@ -0,0 +1,39 @@
+/**
+ * Test Runner Report Generation
+ * 
+ * Generates comprehensive test reports.
+ */
+
+const { compareResults } = require('./test-comparator');
+const { getTestConfig } = require('./test-config');
+
+/**
+ * Generate test report
+ */
+function generateReport(runner) {
+  if (!runner.getCurrentResults()) {
+    throw new Error('No test results available. Run tests first.');
+  }
+
+  const baselineResults = runner.getBaselineResults();
+  const currentResults = runner.getCurrentResults();
+
+  const report = {
+    timestamp: new Date().toISOString(),
+    baseline: baselineResults,
+    current: currentResults,
+    comparison: compareResults(baselineResults, currentResults),
+    config: getTestConfig(),
+    summary: {
+      hasRegressions: runner.hasRegressions(),
+      testCountChanged: baselineResults.total !== currentResults.total,
+      performanceChanged: Math.abs(currentResults.duration - baselineResults.duration) > 1000
+    }
+  };
+
+  return report;
+}
+
+module.exports = {
+  generateReport
+};

package/src/utils/test-runner-validation.js

@@ -0,0 +1,71 @@
+/**
+ * Test Runner Validation Operations
+ * 
+ * Handles validation test execution after refactoring.
+ */
+
+const { runSpecificTests } = require('./test-executor');
+const { parseBasicOutput } = require('./test-parser');
+const { compareResults } = require('./test-comparator');
+const { executeTestsAndCollect } = require('./test-runner-baseline');
+
+/**
+ * Run tests after refactoring
+ */
+async function runValidation(runner) {
+  if (!runner.getBaselineResults()) {
+    throw new Error('Baseline results not available. Run baseline first.');
+  }
+
+  console.log('Running validation tests...');
+  
+  try {
+    const results = await executeTestsAndCollect({
+      verbose: runner.options.verbose,
+      timeout: runner.options.timeout
+    });
+    
+    runner.setCurrentResults(results);
+    
+    // Compare with baseline
+    const comparison = compareResults(runner.getBaselineResults(), results);
+    runner.setRegressionDetected(comparison.hasRegressions);
+    
+    console.log(`Validation completed: ${results.passed}/${results.total} passed`);
+    
+    if (comparison.hasRegressions) {
+      console.log(`⚠️  Regressions detected: ${comparison.regressions.length}`);
+    }
+    
+    return {
+      results,
+      comparison,
+      hasRegressions: comparison.hasRegressions
+    };
+  } catch (error) {
+    throw new Error(`Validation test execution failed: ${error.message}`);
+  }
+}
+
+/**
+ * Run specific test files
+ */
+async function runSpecific(testFiles, options = {}) {
+  const executionResult = await runSpecificTests(testFiles, {
+    verbose: options.verbose || false
+  });
+  
+  const results = parseBasicOutput(
+    executionResult.stdout,
+    executionResult.stderr,
+    executionResult.exitCode,
+    executionResult.duration
+  );
+  
+  return results;
+}
+
+module.exports = {
+  runValidation,
+  runSpecific
+};