vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/utils/smoke-test-gui.js

@@ -0,0 +1,351 @@
+/**
+ * GUI Smoke Testing Utility
+ * 
+ * Provides smoke testing functionality for the GUI (Electron) interface
+ * to ensure it starts without critical errors.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+class GuiSmokeTest {
+  constructor(options = {}) {
+    this.guiPath = options.guiPath || path.join(__dirname, '../../../electron-app');
+    this.mainScript = options.mainScript || 'src/main.js';
+    this.timeout = options.timeout || 45000; // 45 seconds for Electron startup
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Run comprehensive GUI smoke tests
+   * @returns {Promise<Object>} Test results
+   */
+  async runSmokeTests() {
+    const results = {
+      passed: 0,
+      failed: 0,
+      total: 0,
+      details: []
+    };
+
+    const tests = [
+      { name: 'GUI Directory Exists', test: () => this.testGuiDirectoryExists() },
+      { name: 'Package.json Exists', test: () => this.testPackageJsonExists() },
+      { name: 'Main Script Exists', test: () => this.testMainScriptExists() },
+      { name: 'Dependencies Available', test: () => this.testDependenciesAvailable() },
+      { name: 'GUI Starts Without Crashing', test: () => this.testGuiStarts() }
+    ];
+
+    for (const test of tests) {
+      results.total++;
+      try {
+        const result = await test.test();
+        if (result.passed) {
+          results.passed++;
+          if (this.verbose) {
+            console.log(`✅ ${test.name}: PASSED`);
+          }
+        } else {
+          results.failed++;
+          console.error(`❌ ${test.name}: FAILED - ${result.error}`);
+        }
+        results.details.push({
+          name: test.name,
+          passed: result.passed,
+          error: result.error,
+          details: result.details
+        });
+      } catch (error) {
+        results.failed++;
+        console.error(`❌ ${test.name}: ERROR - ${error.message}`);
+        results.details.push({
+          name: test.name,
+          passed: false,
+          error: error.message,
+          details: null
+        });
+      }
+    }
+
+    return {
+      success: results.failed === 0,
+      ...results
+    };
+  }
+
+  /**
+   * Test if GUI directory exists
+   */
+  async testGuiDirectoryExists() {
+    try {
+      const exists = fs.existsSync(this.guiPath);
+      if (!exists) {
+        return { passed: false, error: `GUI directory not found: ${this.guiPath}` };
+      }
+
+      const stats = fs.statSync(this.guiPath);
+      if (!stats.isDirectory()) {
+        return { passed: false, error: `GUI path is not a directory: ${this.guiPath}` };
+      }
+
+      return { passed: true, details: { path: this.guiPath } };
+    } catch (error) {
+      return { passed: false, error: error.message };
+    }
+  }
+
+  /**
+   * Test if package.json exists in GUI directory
+   */
+  async testPackageJsonExists() {
+    try {
+      const packageJsonPath = path.join(this.guiPath, 'package.json');
+      const exists = fs.existsSync(packageJsonPath);
+      if (!exists) {
+        return { passed: false, error: `package.json not found: ${packageJsonPath}` };
+      }
+
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      return { 
+        passed: true, 
+        details: { 
+          name: packageJson.name,
+          version: packageJson.version,
+          hasMain: !!packageJson.main
+        } 
+      };
+    } catch (error) {
+      return { passed: false, error: `package.json error: ${error.message}` };
+    }
+  }
+
+  /**
+   * Test if main script exists
+   */
+  async testMainScriptExists() {
+    try {
+      const mainScriptPath = path.join(this.guiPath, this.mainScript);
+      const exists = fs.existsSync(mainScriptPath);
+      if (!exists) {
+        return { passed: false, error: `Main script not found: ${mainScriptPath}` };
+      }
+
+      const stats = fs.statSync(mainScriptPath);
+      return { 
+        passed: true, 
+        details: { 
+          path: mainScriptPath, 
+          size: stats.size 
+        } 
+      };
+    } catch (error) {
+      return { passed: false, error: error.message };
+    }
+  }
+
+  /**
+   * Test if dependencies are available
+   */
+  async testDependenciesAvailable() {
+    try {
+      const packageJsonPath = path.join(this.guiPath, 'package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const nodeModulesPath = path.join(this.guiPath, 'node_modules');
+
+      const nodeModulesExists = fs.existsSync(nodeModulesPath);
+      const hasDependencies = packageJson.dependencies && Object.keys(packageJson.dependencies).length > 0;
+
+      if (!nodeModulesExists && hasDependencies) {
+        return { 
+          passed: false, 
+          error: 'node_modules directory not found but dependencies exist in package.json' 
+        };
+      }
+
+      // Check for key Electron dependencies
+      const keyDeps = ['electron'];
+      const missingDeps = keyDeps.filter(dep => 
+        packageJson.dependencies && packageJson.dependencies[dep] && 
+        !fs.existsSync(path.join(nodeModulesPath, dep))
+      );
+
+      if (missingDeps.length > 0) {
+        return { 
+          passed: false, 
+          error: `Missing key dependencies: ${missingDeps.join(', ')}` 
+        };
+      }
+
+      return { 
+        passed: true, 
+        details: { 
+          nodeModulesExists,
+          dependencyCount: hasDependencies ? Object.keys(packageJson.dependencies).length : 0,
+          hasElectron: packageJson.dependencies && !!packageJson.dependencies.electron
+        } 
+      };
+    } catch (error) {
+      return { passed: false, error: `Dependency check error: ${error.message}` };
+    }
+  }
+
+  /**
+   * Test if GUI starts without crashing
+   * Note: This is a basic startup test - we don't actually launch the full GUI
+   * as that would require a display environment
+   */
+  async testGuiStarts() {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      
+      // Try to run electron with --version to test if it can start
+      const electronPath = path.join(this.guiPath, 'node_modules', '.bin', 'electron');
+      const packageJsonPath = path.join(this.guiPath, 'package.json');
+      
+      // Check if electron binary exists
+      if (!fs.existsSync(electronPath)) {
+        // Try alternative paths
+        const electronPaths = [
+          path.join(this.guiPath, 'node_modules', 'electron', 'dist', 'electron'),
+          path.join(this.guiPath, 'node_modules', '.bin', 'electron.cmd'),
+          'npx electron'
+        ];
+        
+        let foundElectron = false;
+        for (const ePath of electronPaths) {
+          if (ePath.includes('npx') || fs.existsSync(ePath)) {
+            foundElectron = true;
+            break;
+          }
+        }
+        
+        if (!foundElectron) {
+          resolve({
+            passed: false,
+            error: 'Electron binary not found'
+          });
+          return;
+        }
+      }
+
+      // Test electron version
+      const child = spawn('npm', ['run', 'electron:version'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: this.guiPath,
+        timeout: this.timeout
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        resolve({
+          passed: false,
+          error: `GUI startup test timeout after ${this.timeout}ms`,
+          details: { stdout, stderr }
+        });
+      }, this.timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        const duration = Date.now() - startTime;
+        
+        // If electron:version script doesn't exist, try alternative test
+        if (code === 1 && stderr.includes('Missing script')) {
+          // Try to validate package.json main entry point
+          try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            const mainEntry = packageJson.main || this.mainScript;
+            const mainEntryPath = path.join(this.guiPath, mainEntry);
+            
+            if (fs.existsSync(mainEntryPath)) {
+              resolve({
+                passed: true,
+                details: { 
+                  test: 'package-json-validation',
+                  mainEntry,
+                  mainEntryExists: true,
+                  duration
+                }
+              });
+            } else {
+              resolve({
+                passed: false,
+                error: `Main entry point not found: ${mainEntryPath}`,
+                details: { mainEntry, duration }
+              });
+            }
+          } catch (error) {
+            resolve({
+              passed: false,
+              error: `Package.json validation failed: ${error.message}`,
+              details: { duration }
+            });
+          }
+        } else if (code === 0) {
+          resolve({
+            passed: true,
+            details: { 
+              exitCode: code,
+              duration,
+              electronVersion: stdout.trim()
+            }
+          });
+        } else {
+          resolve({
+            passed: false,
+            error: `GUI startup test failed - exit code: ${code}`,
+            details: { exitCode: code, stdout, stderr, duration }
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        
+        // If npm script fails, try basic validation
+        try {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+          const mainEntry = packageJson.main || this.mainScript;
+          const mainEntryPath = path.join(this.guiPath, mainEntry);
+          
+          if (fs.existsSync(mainEntryPath)) {
+            resolve({
+              passed: true,
+              details: { 
+                test: 'fallback-validation',
+                mainEntry,
+                mainEntryExists: true,
+                note: 'npm script failed but main entry exists'
+              }
+            });
+          } else {
+            resolve({
+              passed: false,
+              error: `Main entry point not found: ${mainEntryPath}`,
+              details: { error: error.message }
+            });
+          }
+        } catch (validationError) {
+          resolve({
+            passed: false,
+            error: `GUI startup test error: ${error.message}`,
+            details: { error: error.message }
+          });
+        }
+      });
+    });
+  }
+}
+
+module.exports = { GuiSmokeTest };

package/src/utils/smoke-test-orchestrator.js

@@ -0,0 +1,321 @@
+/**
+ * Smoke Test Orchestrator
+ * 
+ * Coordinates smoke testing across all interfaces (CLI, GUI, Web)
+ * and provides unified reporting and rollback triggering.
+ */
+
+const { CliSmokeTest } = require('./smoke-test-cli');
+const { GuiSmokeTest } = require('./smoke-test-gui');
+const { WebSmokeTest } = require('./smoke-test-web');
+
+class SmokeTestOrchestrator {
+  constructor(options = {}) {
+    this.options = {
+      cliPath: options.cliPath,
+      guiPath: options.guiPath,
+      webPath: options.webPath,
+      timeout: options.timeout || 120000, // 2 minutes total
+      parallel: options.parallel !== false, // Run tests in parallel by default
+      verbose: options.verbose || false,
+      rollbackTrigger: options.rollbackTrigger || null
+    };
+
+    this.testers = {
+      cli: new CliSmokeTest({ 
+        cliPath: this.options.cliPath, 
+        verbose: this.options.verbose 
+      }),
+      gui: new GuiSmokeTest({ 
+        guiPath: this.options.guiPath, 
+        verbose: this.options.verbose 
+      }),
+      web: new WebSmokeTest({ 
+        webPath: this.options.webPath, 
+        verbose: this.options.verbose 
+      })
+    };
+  }
+
+  /**
+   * Run smoke tests for all interfaces
+   * @param {string} phase - 'pre-refactor' or 'post-refactor'
+   * @returns {Promise<Object>} Comprehensive test results
+   */
+  async runSmokeTests(phase = 'pre-refactor') {
+    const startTime = Date.now();
+    const results = {
+      phase,
+      timestamp: new Date().toISOString(),
+      totalDuration: 0,
+      interfaces: {},
+      summary: {
+        totalTests: 0,
+        passedTests: 0,
+        failedTests: 0,
+        interfacesPassed: 0,
+        interfacesFailed: 0
+      },
+      success: false,
+      rollbackTriggered: false
+    };
+
+    if (this.options.verbose) {
+      console.log(`\n🔥 Running ${phase} smoke tests...`);
+    }
+
+    const interfaceTests = [
+      { name: 'cli', tester: this.testers.cli, required: true },
+      { name: 'gui', tester: this.testers.gui, required: false }, // GUI might not be always available
+      { name: 'web', tester: this.testers.web, required: false }  // Web might not be always available
+    ];
+
+    if (this.options.parallel) {
+      // Run all tests in parallel
+      const testPromises = interfaceTests.map(async (interfaceTest) => {
+        try {
+          const testResult = await interfaceTest.tester.runSmokeTests();
+          return {
+            name: interfaceTest.name,
+            required: interfaceTest.required,
+            result: testResult
+          };
+        } catch (error) {
+          return {
+            name: interfaceTest.name,
+            required: interfaceTest.required,
+            result: {
+              success: false,
+              error: error.message,
+              passed: 0,
+              failed: 0,
+              total: 0,
+              details: []
+            }
+          };
+        }
+      });
+
+      const interfaceResults = await Promise.all(testPromises);
+      
+      // Process results
+      interfaceResults.forEach(({ name, required, result }) => {
+        results.interfaces[name] = {
+          ...result,
+          required,
+          available: true
+        };
+        
+        results.summary.totalTests += result.total;
+        results.summary.passedTests += result.passed;
+        results.summary.failedTests += result.failed;
+        
+        if (result.success) {
+          results.summary.interfacesPassed++;
+        } else {
+          results.summary.interfacesFailed++;
+        }
+      });
+    } else {
+      // Run tests sequentially
+      for (const interfaceTest of interfaceTests) {
+        try {
+          const testResult = await interfaceTest.tester.runSmokeTests();
+          results.interfaces[interfaceTest.name] = {
+            ...testResult,
+            required: interfaceTest.required,
+            available: true
+          };
+          
+          results.summary.totalTests += testResult.total;
+          results.summary.passedTests += testResult.passed;
+          results.summary.failedTests += testResult.failed;
+          
+          if (testResult.success) {
+            results.summary.interfacesPassed++;
+          } else {
+            results.summary.interfacesFailed++;
+          }
+        } catch (error) {
+          results.interfaces[interfaceTest.name] = {
+            success: false,
+            error: error.message,
+            passed: 0,
+            failed: 0,
+            total: 0,
+            details: [],
+            required: interfaceTest.required,
+            available: false
+          };
+          
+          results.summary.interfacesFailed++;
+        }
+      }
+    }
+
+    results.totalDuration = Date.now() - startTime;
+    
+    // Determine overall success
+    const requiredInterfaces = interfaceTests
+      .filter(iface => iface.required)
+      .map(iface => iface.name);
+    
+    const requiredInterfacesPassed = requiredInterfaces
+      .filter(name => results.interfaces[name] && results.interfaces[name].success)
+      .length;
+
+    // Success if all required interfaces pass
+    results.success = requiredInterfacesPassed === requiredInterfaces.length;
+
+    // Trigger rollback if this is post-refactor and tests failed
+    if (phase === 'post-refactor' && !results.success && this.options.rollbackTrigger) {
+      if (this.options.verbose) {
+        console.log('🚨 Smoke tests failed - triggering rollback');
+      }
+      
+      try {
+        await this.options.rollbackTrigger({
+          reason: 'Smoke tests failed',
+          phase,
+          results
+        });
+        results.rollbackTriggered = true;
+      } catch (rollbackError) {
+        console.error('Rollback trigger failed:', rollbackError.message);
+        results.rollbackError = rollbackError.message;
+      }
+    }
+
+    // Print summary
+    this.printSummary(results);
+
+    return results;
+  }
+
+  /**
+   * Run pre-refactor smoke tests
+   */
+  async runPreRefactorTests() {
+    return this.runSmokeTests('pre-refactor');
+  }
+
+  /**
+   * Run post-refactor smoke tests
+   */
+  async runPostRefactorTests() {
+    return this.runSmokeTests('post-refactor');
+  }
+
+  /**
+   * Print test summary to console
+   */
+  printSummary(results) {
+    if (this.options.verbose) {
+      console.log(`\n📊 Smoke Test Results - ${results.phase.toUpperCase()}`);
+      console.log(`⏱️  Duration: ${results.totalDuration}ms`);
+      console.log(`📈 Summary: ${results.summary.passedTests}/${results.summary.totalTests} tests passed`);
+      console.log(`🖥️  Interfaces: ${results.summary.interfacesPassed}/${results.summary.interfacesPassed + results.summary.interfacesFailed} passed`);
+      
+      Object.entries(results.interfaces).forEach(([name, result]) => {
+        const status = result.success ? '✅' : '❌';
+        const availability = result.available ? '' : ' (not available)';
+        const requirement = result.required ? ' (required)' : ' (optional)';
+        console.log(`   ${status} ${name.toUpperCase()}${availability}${requirement}: ${result.passed}/${result.total} tests passed`);
+        
+        if (!result.success && result.error) {
+          console.log(`      Error: ${result.error}`);
+        }
+      });
+      
+      if (results.success) {
+        console.log('🎉 All required interfaces passed smoke tests!');
+      } else {
+        console.log('💥 Some required interfaces failed smoke tests!');
+      }
+      
+      if (results.rollbackTriggered) {
+        console.log('🔄 Rollback was triggered due to failures');
+      }
+    }
+  }
+
+  /**
+   * Generate detailed report
+   */
+  generateReport(results) {
+    const report = {
+      metadata: {
+        phase: results.phase,
+        timestamp: results.timestamp,
+        duration: results.totalDuration,
+        orchestratorVersion: '1.0.0'
+      },
+      summary: results.summary,
+      interfaces: {},
+      recommendations: []
+    };
+
+    // Process each interface result
+    Object.entries(results.interfaces).forEach(([name, result]) => {
+      report.interfaces[name] = {
+        available: result.available,
+        required: result.required,
+        success: result.success,
+        testSummary: {
+          total: result.total,
+          passed: result.passed,
+          failed: result.failed
+        },
+        error: result.error || null,
+        testDetails: result.details || []
+      };
+
+      // Generate recommendations
+      if (!result.success) {
+        if (result.error && result.error.includes('not found')) {
+          report.recommendations.push({
+            interface: name,
+            priority: 'high',
+            issue: 'Missing files or dependencies',
+            suggestion: `Ensure ${name} interface is properly installed and dependencies are available`
+          });
+        } else if (result.error && result.error.includes('timeout')) {
+          report.recommendations.push({
+            interface: name,
+            priority: 'medium',
+            issue: 'Startup timeout',
+            suggestion: `Check ${name} configuration and increase timeout if necessary`
+          });
+        } else {
+          report.recommendations.push({
+            interface: name,
+            priority: 'high',
+            issue: 'Unknown error',
+            suggestion: `Investigate ${name} interface logs and configuration`
+          });
+        }
+      }
+    });
+
+    return report;
+  }
+
+  /**
+   * Save report to file
+   */
+  async saveReport(results, filePath) {
+    const fs = require('fs').promises;
+    const report = this.generateReport(results);
+    
+    try {
+      await fs.writeFile(filePath, JSON.stringify(report, null, 2));
+      if (this.options.verbose) {
+        console.log(`📄 Report saved to: ${filePath}`);
+      }
+    } catch (error) {
+      console.error(`Failed to save report: ${error.message}`);
+    }
+  }
+}
+
+module.exports = { SmokeTestOrchestrator };