vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/windows/WinGetInstaller.js

@@ -0,0 +1,390 @@
+/**
+ * WinGet Installer
+ * 
+ * Windows Package Manager (WinGet) installer implementation.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const BaseWindowsInstaller = require('./BaseWindowsInstaller');
+const { InstallationType } = require('../InstallationType');
+
+/**
+ * WinGet installer class for Windows agents
+ */
+class WinGetInstaller extends BaseWindowsInstaller {
+  /**
+   * Create WinGet installer instance
+   * @param {Object} config - Installer configuration
+   */
+  constructor(config = {}) {
+    super({
+      type: InstallationType.WINGET,
+      ...config
+    });
+  }
+
+  /**
+   * Check if WinGet is available on current system
+   * @returns {Promise<boolean>} - True if WinGet is available
+   */
+  async isAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('winget --version', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('WinGet not available', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Check system requirements for WinGet
+   * @returns {Promise<Object>} - Requirements check result
+   */
+  async checkRequirements() {
+    const requirements = await super.checkRequirements();
+    
+    // WinGet-specific requirements
+    const wingetRequirements = [
+      { requirement: 'windows', met: process.platform === 'win32' },
+      { requirement: 'winget', met: await this.isAvailable() },
+      { requirement: 'windows-10-or-later', met: await this.checkWindowsVersion() }
+    ];
+
+    wingetRequirements.forEach(req => {
+      requirements.requirements.push(req);
+      if (!req.met) {
+        requirements.allMet = false;
+      }
+    });
+
+    return requirements;
+  }
+
+  /**
+   * Check if Windows version is 10 or later
+   * @returns {Promise<boolean>} - True if Windows 10 or later
+   */
+  async checkWindowsVersion() {
+    try {
+      const { execSync } = require('child_process');
+      const output = execSync('ver', { encoding: 'utf8' });
+      
+      // Parse Windows version from output
+      // Format: "Microsoft Windows [Version 10.0.19044]"
+      const match = output.match(/Version (\d+)\.(\d+)/);
+      if (match) {
+        const majorVersion = parseInt(match[1], 10);
+        return majorVersion >= 10;
+      }
+      
+      return false;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Failed to check Windows version', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Perform actual installation using WinGet
+   * @param {boolean} force - Force reinstall
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async performInstallation(force, timeout) {
+    const command = this.buildInstallCommand(force);
+    
+    if (this.logger) {
+      await this.logger.info('Installing with WinGet', {
+        packageId: this.packageId,
+        command,
+        force
+      });
+    }
+
+    try {
+      const result = await this.executeCommand(command, timeout);
+      
+      if (this.logger) {
+        await this.logger.info('WinGet installation completed', {
+          packageId: this.packageId,
+          success: result.success,
+          exitCode: result.exitCode,
+          duration: result.duration
+        });
+      }
+
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        duration: result.duration,
+        command,
+        installer: 'winget'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('WinGet installation failed', {
+          packageId: this.packageId,
+          error: error.message,
+          command
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Build WinGet install command
+   * @param {boolean} force - Force reinstall
+   * @returns {string} - WinGet command
+   */
+  buildInstallCommand(force) {
+    let command = `winget install ${this.packageId}`;
+    
+    // Add WinGet-specific options
+    command += ' --accept-package-agreements --accept-source-agreements';
+    
+    // Add force flag if requested
+    if (force) {
+      command += ' --force';
+    }
+    
+    // Add silent installation
+    command += ' --silent';
+    
+    // Add architecture if specified
+    if (this.architecture) {
+      command += ` --architecture ${this.architecture}`;
+    }
+    
+    return command;
+  }
+
+  /**
+   * Perform verification using WinGet
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performVerification() {
+    try {
+      // First check if package is installed using WinGet list
+      const listCommand = `winget list --id ${this.packageId}`;
+      const listResult = await this.executeCommand(listCommand, 30000);
+      
+      if (!listResult.success) {
+        return {
+          success: false,
+          error: 'Package not found in WinGet list',
+          exitCode: listResult.exitCode,
+          stdout: listResult.stdout,
+          stderr: listResult.stderr,
+          installer: 'winget'
+        };
+      }
+
+      // Check if package is actually installed
+      const isInstalled = listResult.stdout.includes(this.packageId) || 
+                        listResult.stdout.toLowerCase().includes(this.packageId.toLowerCase());
+
+      if (!isInstalled) {
+        return {
+          success: false,
+          error: 'Package not properly installed',
+          exitCode: 1,
+          stdout: listResult.stdout,
+          stderr: listResult.stderr,
+          installer: 'winget'
+        };
+      }
+
+      // Run verification command if provided
+      if (this.verificationCommand) {
+        const verifyResult = await this.executeCommand(this.verificationCommand, 30000);
+        
+        return {
+          success: verifyResult.success,
+          exitCode: verifyResult.exitCode,
+          stdout: verifyResult.stdout,
+          stderr: verifyResult.stderr,
+          installer: 'winget',
+          verified: verifyResult.success
+        };
+      }
+
+      return {
+        success: true,
+        exitCode: 0,
+        stdout: listResult.stdout,
+        stderr: '',
+        installer: 'winget',
+        verified: true
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('WinGet verification failed', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get installed version using WinGet
+   * @returns {Promise<string|null>} - Version string or null
+   */
+  async getInstalledVersion() {
+    try {
+      const command = `winget show --id ${this.packageId}`;
+      const result = await this.executeCommand(command, 30000);
+      
+      if (result.success) {
+        // Parse version from output
+        const lines = result.stdout.split('\n');
+        const versionLine = lines.find(line => 
+          line.toLowerCase().includes('version') || 
+          line.toLowerCase().includes('version')
+        );
+        
+        if (versionLine) {
+          const match = versionLine.match(/(\d+\.\d+\.\d+)/);
+          return match ? match[1] : null;
+        }
+      }
+      
+      return null;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Failed to get installed version', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Uninstall package using WinGet
+   * @returns {Promise<Object>} - Uninstallation result
+   */
+  async uninstall() {
+    try {
+      const command = `winget uninstall ${this.packageId} --silent`;
+      
+      if (this.logger) {
+        await this.logger.info('Uninstalling with WinGet', {
+          packageId: this.packageId,
+          command
+        });
+      }
+
+      const result = await this.executeCommand(command, 300000); // 5 minute timeout
+      
+      if (this.logger) {
+        await this.logger.info('WinGet uninstallation completed', {
+          packageId: this.packageId,
+          success: result.success,
+          exitCode: result.exitCode,
+          duration: result.duration
+        });
+      }
+
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        duration: result.duration,
+        installer: 'winget'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('WinGet uninstallation failed', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Update package using WinGet
+   * @returns {Promise<Object>} - Update result
+   */
+  async update() {
+    try {
+      const command = `winget upgrade ${this.packageId} --silent`;
+      
+      if (this.logger) {
+        await this.logger.info('Updating with WinGet', {
+          packageId: this.packageId,
+          command
+        });
+      }
+
+      const result = await this.executeCommand(command, 300000); // 5 minute timeout
+      
+      if (this.logger) {
+        await this.logger.info('WinGet update completed', {
+          packageId: this.packageId,
+          success: result.success,
+          exitCode: result.exitCode,
+          duration: result.duration
+        });
+      }
+
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        duration: result.duration,
+        installer: 'winget'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('WinGet update failed', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get WinGet-specific information
+   * @returns {Object} - WinGet installer info
+   */
+  getInstallerInfo() {
+    return {
+      ...this.getInfo(),
+      installer: 'winget',
+      supportedPlatforms: ['win32'],
+      minimumWindowsVersion: '10.0',
+      supportedArchitectures: ['x64', 'arm64'],
+      features: [
+        'automatic updates',
+        'dependency resolution',
+        'silent installation',
+        'version management'
+      ],
+      limitations: [
+        'Windows 10+ only',
+        'requires WinGet installation',
+        'limited package repository'
+      ]
+    };
+  }
+}
+
+module.exports = WinGetInstaller;

package/src/analysis/analysis-reporter.js

@@ -0,0 +1,132 @@
+/**
+ * Analysis Reporter
+ * 
+ * Generates comprehensive analysis reports with refactoring recommendations.
+ * Integrates multiple analysis components into actionable insights.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { ReportGenerator } = require('../utils/report-generator');
+const RefactoringConfig = require('../config/refactoring-config');
+
+// Import modular components
+const AnalysisReport = require('./report/analysis-report');
+const PackageAnalyzer = require('./report/package-analyzer');
+const RecommendationGenerator = require('./report/recommendation-generator');
+const StatisticsGenerator = require('./report/statistics-generator');
+
+/**
+ * Analysis reporter class
+ */
+class AnalysisReporter {
+  constructor(config = RefactoringConfig) {
+    this.config = config;
+    this.reportGenerator = new ReportGenerator(config);
+    this.report = new AnalysisReport();
+    this.packageAnalyzer = new PackageAnalyzer();
+    this.recommendationGenerator = new RecommendationGenerator();
+    this.statisticsGenerator = new StatisticsGenerator();
+  }
+
+  /**
+   * Generate comprehensive analysis report
+   */
+  async generateReport(analysisData, options = {}) {
+    console.log('Generating comprehensive analysis report...');
+    
+    // Initialize report with metadata
+    this.report.metadata.analysisScope = options.scope || 'full_codebase';
+    this.report.metadata.targetPackages = options.packages || [];
+    
+    // Process file analyses
+    for (const fileAnalysis of analysisData.files || []) {
+      this.report.addFileAnalysis(fileAnalysis);
+    }
+    
+    // Generate package analysis
+    const packageAnalysis = this.packageAnalyzer.analyzePackages(analysisData.files || []);
+    for (const [packageName, analysis] of Object.entries(packageAnalysis)) {
+      this.report.addPackageAnalysis(packageName, analysis);
+    }
+    
+    // Generate statistics
+    const statistics = this.statisticsGenerator.generateStatistics(analysisData);
+    this.report.addStatistics(statistics);
+    
+    // Generate recommendations
+    const recommendations = this.recommendationGenerator.generateRecommendations(analysisData);
+    for (const recommendation of recommendations) {
+      this.report.addRecommendation(recommendation);
+      recommendations.forEach(rec => this.report.addRecommendation(rec.title));
+    }
+
+    // Generate reports in requested formats
+    const results = {};
+    for (const format of this.options.formats) {
+      const generator = this.getGenerator(format);
+      if (generator) {
+        const outputPath = this.options.outputPath ? 
+          this.getOutputPath(this.options.outputPath, format) : null;
+        results[format] = generator.generate(outputPath);
+      }
+    }
+
+    return {
+      success: true,
+      report: this.report,
+      generatedFiles: results,
+      summary: this.report.summary
+    };
+  }
+
+  /**
+   * Get report generator for specified format
+   */
+  getGenerator(format) {
+    switch (format.toLowerCase()) {
+      case 'json':
+        return new JSONReportGenerator(this.report);
+      case 'html':
+        return new HTMLReportGenerator(this.report);
+      case 'csv':
+        return new CSVReportGenerator(this.report);
+      default:
+        console.warn(`Unsupported format: ${format}`);
+        return null;
+    }
+  }
+
+  /**
+   * Get output path for specific format
+   */
+  getOutputPath(basePath, format) {
+    const extension = format.toLowerCase();
+    return basePath.endsWith(`.${extension}`) ? basePath : `${basePath}.${extension}`;
+  }
+
+  /**
+   * Generate quick summary (for CLI usage)
+   */
+  generateSummary() {
+    return {
+      totalFiles: this.report.summary.totalFiles,
+      filesNeedingRefactoring: this.report.summary.filesNeedingRefactoring,
+      complianceRate: this.report.summary.complianceRate,
+      urgentFiles: this.report.summary.urgentRefactoring,
+      estimatedEffort: this.statisticsCalculator.calculateTotalEffort()
+    };
+  }
+
+  /**
+   * Export report data
+   */
+  exportData() {
+    return this.report.toJSON();
+  }
+}
+
+module.exports = {
+  AnalysisReporter,
+  AnalysisReport
+};