stigmergy 1.2.0 → 1.2.8

package/test/comprehensive-enhanced-features.test.js

@@ -1,252 +0,0 @@
-/**
- * Comprehensive Enhanced Features Test
- *
- * Tests all enhanced installation and uninstallation features together
- */
-
-const EnhancedInstaller = require('../src/core/enhanced_installer');
-const EnhancedUninstaller = require('../src/core/enhanced_uninstaller');
-const CacheCleaner = require('../src/core/cache_cleaner');
-
-class ComprehensiveEnhancedFeaturesTest {
-  constructor() {
-    this.testResults = [];
-  }
-
-  async runAllTests() {
-    console.log('🧪 Running Comprehensive Enhanced Features Tests...\n');
-
-    try {
-      await this.testEnhancedInstallerPlan();
-      await this.testCacheCleanerStandalone();
-      await this.testEnhancedUninstallerPlan();
-      await this.testIntegrationWorkflow();
-
-      this.printResults();
-    } catch (error) {
-      console.error('❌ Test suite failed:', error.message);
-      this.testResults.push({
-        name: 'Test Suite',
-        status: '❌',
-        error: error.message
-      });
-    }
-  }
-
-  async testEnhancedInstallerPlan() {
-    console.log('📋 TEST 1: Enhanced Installer Plan Creation');
-
-    try {
-      const installer = new EnhancedInstaller({
-        dryRun: true,
-        verbose: false
-      });
-
-      // Create installation plan
-      const plan = await installer.createInstallationPlan();
-
-      // Verify plan structure
-      this.assert(plan !== undefined, 'Should create installation plan');
-      this.assert(typeof plan.estimatedTime === 'number', 'Should estimate installation time');
-      this.assert(typeof plan.estimatedSpace === 'number', 'Should estimate required space');
-
-      console.log(`  ✅ Plan created with ${plan.installation.toolCount} tools to install`);
-      console.log(`  ⏱️  Estimated time: ${Math.ceil(plan.estimatedTime / 1000)} seconds`);
-      console.log(`  💾 Estimated space: ${this.formatBytes(plan.estimatedSpace)}`);
-
-      this.recordResult('Enhanced Installer Plan', '✅');
-
-    } catch (error) {
-      console.log(`  ❌ Error: ${error.message}`);
-      this.recordResult('Enhanced Installer Plan', '❌');
-    }
-  }
-
-  async testCacheCleanerStandalone() {
-    console.log('🧹 TEST 2: Cache Cleaner Standalone');
-
-    try {
-      const cleaner = new CacheCleaner({
-        dryRun: true,
-        verbose: false
-      });
-
-      // Test selective cleaning
-      const testDir = require('os').tmpdir();
-      await cleaner.selectiveClean(testDir, {
-        preservePatterns: ['*.log'],
-        removePatterns: ['*.tmp']
-      });
-
-      // Test performance mode (dry run)
-      await cleaner.cleanWithPerformance(testDir, {
-        batchSize: 10,
-        parallel: false
-      });
-
-      console.log('  ✅ Selective cleaning test passed');
-      console.log('  ✅ Performance mode test passed');
-
-      this.recordResult('Cache Cleaner Standalone', '✅');
-
-    } catch (error) {
-      console.log(`  ❌ Error: ${error.message}`);
-      this.recordResult('Cache Cleaner Standalone', '❌');
-    }
-  }
-
-  async testEnhancedUninstallerPlan() {
-    console.log('🗑️  TEST 3: Enhanced Uninstaller Plan');
-
-    try {
-      const uninstaller = new EnhancedUninstaller({
-        dryRun: true,
-        verbose: false
-      });
-
-      // Create uninstall plan
-      const plan = await uninstaller.createUninstallPlan();
-
-      // Verify plan structure
-      this.assert(plan !== undefined, 'Should create uninstall plan');
-      this.assert(Array.isArray(plan.files), 'Should list files to remove');
-      this.assert(Array.isArray(plan.directories), 'Should list directories to remove');
-
-      console.log(`  ✅ Uninstall plan created`);
-      console.log(`  📁 Files to remove: ${plan.files.length}`);
-      console.log(`  📂 Directories to remove: ${plan.directories.length}`);
-      console.log(`  💾 Estimated space to free: ${this.formatBytes(plan.estimatedSize)}`);
-
-      this.recordResult('Enhanced Uninstaller Plan', '✅');
-
-    } catch (error) {
-      console.log(`  ❌ Error: ${error.message}`);
-      this.recordResult('Enhanced Uninstaller Plan', '❌');
-    }
-  }
-
-  async testIntegrationWorkflow() {
-    console.log('🔄 TEST 4: Integration Workflow');
-
-    try {
-      // Test 1: Cache cleaner dry run
-      const cleaner = new CacheCleaner({ dryRun: true });
-      const cleanResults = await cleaner.cleanAllCaches({
-        cleanStigmergy: false,
-        cleanNPX: false,
-        cleanNPM: false,
-        cleanCLI: false,
-        cleanTemp: true
-      });
-
-      this.assert(cleanResults.filesRemoved === 0, 'Dry run should not remove files');
-
-      // Test 2: Enhanced installer dry run
-      const installer = new EnhancedInstaller({
-        dryRun: true,
-        cleanBeforeInstall: true,
-        cleanTempFiles: true
-      });
-
-      const installResults = await installer.enhancedInstall({
-        cleanStigmergy: false,
-        cleanNPX: false,
-        cleanNPM: false,
-        cleanCLI: false,
-        cleanTemp: true
-      });
-
-      this.assert(installResults.cacheCleaning.success, 'Cache cleaning should succeed in dry run');
-
-      // Test 3: Enhanced uninstaller dry run
-      const uninstaller = new EnhancedUninstaller({ dryRun: true });
-      const uninstallResults = await uninstaller.completeUninstall();
-
-      this.assert(uninstallResults.filesRemoved === 0, 'Dry run uninstall should not remove files');
-
-      console.log('  ✅ Cache cleaner workflow test passed');
-      console.log('  ✅ Enhanced installer workflow test passed');
-      console.log('  ✅ Enhanced uninstaller workflow test passed');
-
-      this.recordResult('Integration Workflow', '✅');
-
-    } catch (error) {
-      console.log(`  ❌ Error: ${error.message}`);
-      this.recordResult('Integration Workflow', '❌');
-    }
-  }
-
-  formatBytes(bytes) {
-    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-    if (bytes === 0) return '0 Bytes';
-    const i = Math.floor(Math.log(bytes) / Math.log(1024));
-    return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
-  }
-
-  assert(condition, message) {
-    if (condition) {
-      console.log(`  ✅ ${message}`);
-    } else {
-      console.log(`  ❌ ${message}`);
-      throw new Error(`Assertion failed: ${message}`);
-    }
-  }
-
-  recordResult(testName, status) {
-    this.testResults.push({ name: testName, status });
-  }
-
-  printResults() {
-    console.log('\n📊 COMPREHENSIVE ENHANCED FEATURES TEST RESULTS:');
-    console.log('=' .repeat(60));
-
-    this.testResults.forEach(result => {
-      if (result.error) {
-        console.log(`${result.status} ${result.name}: ${result.error}`);
-      } else {
-        console.log(`${result.status} ${result.name}`);
-      }
-    });
-
-    const passed = this.testResults.filter(r => r.status === '✅').length;
-    const total = this.testResults.length;
-
-    console.log('\n📈 Summary:');
-    console.log(`Total tests: ${total}`);
-    console.log(`Passed: ${passed}`);
-    console.log(`Failed: ${total - passed}`);
-
-    if (passed === total) {
-      console.log('\n🎉 All enhanced features tests passed!');
-      console.log('✅ Enhanced installation and uninstallation features are ready!');
-      console.log('\n📚 Available Features:');
-      console.log('  🔍 Dry run mode for all operations');
-      console.log('  🧹 Comprehensive cache cleaning');
-      console.log('  📦 Enhanced installer with pre-cleaning');
-      console.log('  🗑️  Complete uninstaller with full cleanup');
-      console.log('  ⚡ Performance-optimized operations');
-      console.log('  🎯 Selective cleaning with patterns');
-      console.log('  🛡️  Error recovery and force mode');
-    } else {
-      console.log('\n❌ Some tests failed. Review the implementation.');
-    }
-
-    console.log('\n💡 Usage Examples:');
-    console.log('  # Create installation plan');
-    console.log('  node -e "const EI=require(\'./src/core/enhanced_installer\'); new EI().createInstallationPlan()"');
-    console.log('');
-    console.log('  # Quick cache clean');
-    console.log('  node -e "const EI=require(\'./src/core/enhanced_installer\'); new EI().quickCacheClean()"');
-    console.log('');
-    console.log('  # Dry run uninstall');
-    console.log('  node -e "const EU=require(\'./src/core/enhanced_uninstaller\'); new EU({dryRun:true}).completeUninstall()"');
-  }
-}
-
-// Run tests if this file is executed directly
-if (require.main === module) {
-  const tests = new ComprehensiveEnhancedFeaturesTest();
-  tests.runAllTests().catch(console.error);
-}
-
-module.exports = ComprehensiveEnhancedFeaturesTest;

package/test/comprehensive-execution-test.js

@@ -1,428 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Comprehensive Execution Test
- * This test thoroughly validates that the improved execution mechanisms
- * will guarantee correct command execution across different platforms
- */
-
-const { spawnSync } = require('child_process');
-const path = require('path');
-const os = require('os');
-
-class ComprehensiveExecutionTest {
-    constructor() {
-        this.testResults = [];
-    }
-    
-    // Test 1: Verify shell execution reliability
-    async testShellExecutionReliability() {
-        console.log('[TEST 1] Verifying shell execution reliability...');
-        
-        try {
-            // Test multiple commands with shell: true
-            const testCommands = [
-                { cmd: 'npm', args: ['--version'] },
-                { cmd: 'node', args: ['--version'] },
-                { cmd: 'echo', args: ['test'] }
-            ];
-            
-            let allPassed = true;
-            
-            for (const test of testCommands) {
-                console.log(`  Testing: ${test.cmd} ${test.args.join(' ')} with shell=true`);
-                
-                const result = spawnSync(test.cmd, test.args, {
-                    encoding: 'utf8',
-                    timeout: 10000,
-                    shell: true
-                });
-                
-                const passed = result.status === 0;
-                console.log(`    Status: ${result.status}, Passed: ${passed}`);
-                
-                if (!passed) {
-                    allPassed = false;
-                    if (result.error) {
-                        console.log(`    Error: ${result.error.message}`);
-                    }
-                }
-            }
-            
-            this.testResults.push({
-                name: 'Shell Execution Reliability',
-                passed: allPassed,
-                details: `All ${testCommands.length} commands executed successfully with shell=true`
-            });
-            
-            return allPassed;
-        } catch (error) {
-            console.log(`  ✗ Failed to test shell execution reliability: ${error.message}`);
-            this.testResults.push({
-                name: 'Shell Execution Reliability',
-                passed: false,
-                details: `Failed to test: ${error.message}`
-            });
-            return false;
-        }
-    }
-    
-    // Test 2: Verify fallback mechanism effectiveness
-    async testFallbackMechanism() {
-        console.log('\n[TEST 2] Verifying fallback mechanism effectiveness...');
-        
-        try {
-            // Simulate the exact fallback logic from our implementation
-            const testCommand = 'npm';
-            const testArgs = ['--version'];
-            
-            console.log(`  Testing fallback mechanism for: ${testCommand} ${testArgs.join(' ')}`);
-            
-            // Step 1: Try with shell=true (should work)
-            console.log('  Step 1: Trying with shell=true...');
-            let result = spawnSync(testCommand, testArgs, {
-                encoding: 'utf8',
-                timeout: 10000,
-                shell: true
-            });
-            
-            const shellWorked = result.status === 0;
-            console.log(`    Shell execution status: ${result.status}`);
-            
-            // Step 2: Simulate fallback (try without shell if first failed)
-            let fallbackWorked = true;
-            if (result.status !== 0 && result.status !== null) {
-                console.log('  Step 2: Simulating fallback to without shell...');
-                result = spawnSync(testCommand, testArgs, {
-                    encoding: 'utf8',
-                    timeout: 10000
-                });
-                
-                fallbackWorked = result.status === 0;
-                console.log(`    Fallback execution status: ${result.status}`);
-            } else {
-                console.log('  Step 2: Skipping fallback (first attempt succeeded)');
-            }
-            
-            const fallbackEffective = shellWorked || fallbackWorked;
-            
-            this.testResults.push({
-                name: 'Fallback Mechanism Effectiveness',
-                passed: fallbackEffective,
-                details: `Shell worked: ${shellWorked}, Fallback effective: ${fallbackEffective}`
-            });
-            
-            return fallbackEffective;
-        } catch (error) {
-            console.log(`  ✗ Failed to test fallback mechanism: ${error.message}`);
-            this.testResults.push({
-                name: 'Fallback Mechanism Effectiveness',
-                passed: false,
-                details: `Failed to test: ${error.message}`
-            });
-            return false;
-        }
-    }
-    
-    // Test 3: Verify timeout and error handling
-    async testTimeoutAndErrorHandling() {
-        console.log('\n[TEST 3] Verifying timeout and error handling...');
-        
-        try {
-            // Test with reasonable timeout
-            console.log('  Testing with 5-second timeout...');
-            const result = spawnSync('npm', ['--version'], {
-                encoding: 'utf8',
-                timeout: 5000, // 5 seconds
-                shell: true
-            });
-            
-            const completedInTime = result.status === 0;
-            console.log(`  Completed in time: ${completedInTime}, Status: ${result.status}`);
-            
-            // Test error handling with invalid command
-            console.log('  Testing error handling with invalid command...');
-            const errorResult = spawnSync('this-command-definitely-does-not-exist', [], {
-                encoding: 'utf8',
-                timeout: 5000,
-                shell: true
-            });
-            
-            const errorHandled = errorResult.status !== 0 || errorResult.error;
-            console.log(`  Error handled properly: ${errorHandled}`);
-            if (errorResult.error) {
-                console.log(`  Error type: ${errorResult.error.code || errorResult.error.message}`);
-            }
-            
-            const bothTestsPassed = completedInTime && errorHandled;
-            
-            this.testResults.push({
-                name: 'Timeout and Error Handling',
-                passed: bothTestsPassed,
-                details: `Timeout handling: ${completedInTime}, Error handling: ${errorHandled}`
-            });
-            
-            return bothTestsPassed;
-        } catch (error) {
-            console.log(`  ✗ Failed to test timeout and error handling: ${error.message}`);
-            this.testResults.push({
-                name: 'Timeout and Error Handling',
-                passed: false,
-                details: `Failed to test: ${error.message}`
-            });
-            return false;
-        }
-    }
-    
-    // Test 4: Verify cross-platform compatibility
-    async testCrossPlatformCompatibility() {
-        console.log('\n[TEST 4] Verifying cross-platform compatibility...');
-        
-        try {
-            const platform = process.platform;
-            console.log(`  Current platform: ${platform}`);
-            
-            // Test platform-specific behaviors
-            let platformCompatible = true;
-            
-            if (platform === 'win32') {
-                console.log('  Testing Windows-specific compatibility...');
-                
-                // Test cmd.exe execution
-                const cmdResult = spawnSync('cmd.exe', ['/c', 'echo test'], {
-                    encoding: 'utf8',
-                    timeout: 5000
-                });
-                
-                const cmdWorks = cmdResult.status === 0;
-                console.log(`  cmd.exe works: ${cmdWorks}`);
-                
-                // Test PowerShell execution
-                const psResult = spawnSync('powershell.exe', ['-Command', 'Write-Output "test"'], {
-                    encoding: 'utf8',
-                    timeout: 10000
-                });
-                
-                const psWorks = psResult.status === 0;
-                console.log(`  PowerShell works: ${psWorks}`);
-                
-                platformCompatible = cmdWorks && psWorks;
-            } else {
-                console.log('  Testing Unix-like platform compatibility...');
-                
-                // Test sh execution
-                const shResult = spawnSync('sh', ['-c', 'echo test'], {
-                    encoding: 'utf8',
-                    timeout: 5000
-                });
-                
-                const shWorks = shResult.status === 0;
-                console.log(`  sh works: ${shWorks}`);
-                
-                platformCompatible = shWorks;
-            }
-            
-            this.testResults.push({
-                name: 'Cross-Platform Compatibility',
-                passed: platformCompatible,
-                details: `Platform: ${platform}, Compatible: ${platformCompatible}`
-            });
-            
-            return platformCompatible;
-        } catch (error) {
-            console.log(`  ✗ Failed to test cross-platform compatibility: ${error.message}`);
-            this.testResults.push({
-                name: 'Cross-Platform Compatibility',
-                passed: false,
-                details: `Failed to test: ${error.message}`
-            });
-            return false;
-        }
-    }
-    
-    // Test 5: Verify environment variable handling
-    async testEnvironmentVariableHandling() {
-        console.log('\n[TEST 5] Verifying environment variable handling...');
-        
-        try {
-            // Test with inherited environment
-            console.log('  Testing with inherited environment...');
-            const result1 = spawnSync('npm', ['--version'], {
-                encoding: 'utf8',
-                timeout: 10000,
-                shell: true,
-                env: process.env
-            });
-            
-            const inheritedEnvWorks = result1.status === 0;
-            console.log(`  Inherited environment works: ${inheritedEnvWorks}`);
-            
-            // Test with minimal environment
-            console.log('  Testing with minimal environment...');
-            const minimalEnv = {
-                PATH: process.env.PATH,
-                HOME: process.env.HOME,
-                USERPROFILE: process.env.USERPROFILE, // Windows
-                HOMEPATH: process.env.HOMEPATH // Windows
-            };
-            
-            const result2 = spawnSync('npm', ['--version'], {
-                encoding: 'utf8',
-                timeout: 10000,
-                shell: true,
-                env: minimalEnv
-            });
-            
-            const minimalEnvWorks = result2.status === 0;
-            console.log(`  Minimal environment works: ${minimalEnvWorks}`);
-            
-            const envHandlingGood = inheritedEnvWorks || minimalEnvWorks;
-            
-            this.testResults.push({
-                name: 'Environment Variable Handling',
-                passed: envHandlingGood,
-                details: `Inherited env: ${inheritedEnvWorks}, Minimal env: ${minimalEnvWorks}`
-            });
-            
-            return envHandlingGood;
-        } catch (error) {
-            console.log(`  ✗ Failed to test environment variable handling: ${error.message}`);
-            this.testResults.push({
-                name: 'Environment Variable Handling',
-                passed: false,
-                details: `Failed to test: ${error.message}`
-            });
-            return false;
-        }
-    }
-    
-    // Test 6: Simulate real installation scenario
-    async testRealInstallationScenario() {
-        console.log('\n[TEST 6] Simulating real installation scenario...');
-        
-        try {
-            // Simulate the exact logic used in the improved implementation
-            const toolInfo = {
-                name: 'Test CLI Tool',
-                install: 'npm install -g @qoder-ai/qodercli'
-            };
-            
-            console.log(`  Simulating installation for: ${toolInfo.name}`);
-            console.log(`  Install command: ${toolInfo.install}`);
-            
-            const installCmd = toolInfo.install.split(' ');
-            console.log(`  Command parts: ${JSON.stringify(installCmd)}`);
-            
-            // Exact implementation from our improved code
-            console.log('  Executing with improved implementation...');
-            
-            // Try with shell=true first (works better on Windows)
-            let result = spawnSync(installCmd[0], installCmd.slice(1), {
-                encoding: 'utf8',
-                timeout: 300000, // 5 minutes
-                stdio: 'pipe', // Use pipe for testing
-                env: process.env,
-                shell: true
-            });
-
-            // If shell=true fails, try without shell
-            if (result.status !== 0 && result.status !== null) {
-                console.log('  Shell execution failed, trying without shell...');
-                result = spawnSync(installCmd[0], installCmd.slice(1), {
-                    encoding: 'utf8',
-                    timeout: 300000,
-                    stdio: 'pipe',
-                    env: process.env
-                });
-            }
-
-            const installationWouldWork = result.status === 0 || result.status === null; // null means timeout or killed
-            
-            console.log(`  Final result status: ${result.status}`);
-            if (result.error) {
-                console.log(`  Error (if any): ${result.error.message}`);
-            }
-            
-            this.testResults.push({
-                name: 'Real Installation Scenario',
-                passed: installationWouldWork,
-                details: `Final status: ${result.status}, Would work: ${installationWouldWork}`
-            });
-            
-            return installationWouldWork;
-        } catch (error) {
-            console.log(`  ✗ Failed to simulate real installation scenario: ${error.message}`);
-            this.testResults.push({
-                name: 'Real Installation Scenario',
-                passed: false,
-                details: `Failed to simulate: ${error.message}`
-            });
-            return false;
-        }
-    }
-    
-    // Run all tests
-    async runAllTests() {
-        console.log('Comprehensive Execution Test');
-        console.log('='.repeat(40));
-        
-        await this.testShellExecutionReliability();
-        await this.testFallbackMechanism();
-        await this.testTimeoutAndErrorHandling();
-        await this.testCrossPlatformCompatibility();
-        await this.testEnvironmentVariableHandling();
-        await this.testRealInstallationScenario();
-        
-        // Summary
-        console.log('\n' + '='.repeat(40));
-        console.log('Comprehensive Execution Test Summary:');
-        console.log('='.repeat(40));
-        
-        let passedTests = 0;
-        this.testResults.forEach(result => {
-            console.log(`${result.name}: ${result.passed ? '✓ PASS' : '✗ FAIL'} - ${result.details}`);
-            if (result.passed) passedTests++;
-        });
-        
-        const totalTests = this.testResults.length;
-        console.log(`\nOverall Result: ${passedTests}/${totalTests} tests passed`);
-        
-        if (passedTests === totalTests) {
-            console.log('🎉 ALL TESTS PASSED!');
-            console.log('✅ The improved execution mechanisms WILL guarantee correct command execution!');
-            console.log('✅ Shell strengthening and fallback measures are working perfectly!');
-        } else if (passedTests >= totalTests * 0.8) {
-            console.log('✅ MOST TESTS PASSED!');
-            console.log('✅ The improvements significantly increase execution reliability!');
-        } else {
-            console.log('⚠ SOME TESTS FAILED!');
-            console.log('⚠ Further improvements may be needed.');
-        }
-        
-        return {
-            totalTests: totalTests,
-            passedTests: passedTests,
-            results: this.testResults
-        };
-    }
-}
-
-// Run the tests
-async function runComprehensiveExecutionTests() {
-    const tester = new ComprehensiveExecutionTest();
-    const results = await tester.runAllTests();
-    return results;
-}
-
-// Export for use in other modules
-module.exports = { ComprehensiveExecutionTest };
-
-// Run if called directly
-if (require.main === module) {
-    runComprehensiveExecutionTests().then(results => {
-        process.exit(results.passedTests === results.totalTests ? 0 : 1);
-    }).catch(error => {
-        console.error('[Test Failed]:', error.message);
-        process.exit(1);
-    });
-}