stigmergy 1.1.6 → 1.2.0

package/test/cache-cleaner.test.js

@@ -0,0 +1,390 @@
+/**
+ * TDD Tests for Enhanced Cache Cleaner
+ *
+ * Test-first approach to ensure comprehensive cache cleaning before installation
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class CacheCleanerTests {
+  constructor() {
+    this.testDir = path.join(os.tmpdir(), 'stigmergy-cache-test');
+    this.testResults = [];
+    this.mockCachePaths = [];
+  }
+
+  async runAllTests() {
+    console.log('🧹 Running Enhanced Cache Cleaner TDD Tests...\n');
+
+    await this.setupTestEnvironment();
+
+    try {
+      await this.testStigmergyCacheCleaning();
+      await this.testNPXCacheCleaning();
+      await this.testNPMCacheCleaning();
+      await this.testCLIConfigCacheCleaning();
+      await this.testTemporaryFileCleanup();
+      await this.testSelectiveCacheCleaning();
+      await this.testCacheCleaningPerformance();
+      await this.testErrorRecovery();
+
+      this.printResults();
+    } finally {
+      await this.cleanupTestEnvironment();
+    }
+  }
+
+  async setupTestEnvironment() {
+    console.log('📋 Setting up cache test environment...');
+
+    // Create test directory structure
+    fs.mkdirSync(this.testDir, { recursive: true });
+
+    // Create mock Stigmergy cache
+    const stigmergyCache = path.join(this.testDir, '.stigmergy');
+    fs.mkdirSync(stigmergyCache, { recursive: true });
+    fs.mkdirSync(path.join(stigmergyCache, 'cache'), { recursive: true });
+    fs.mkdirSync(path.join(stigmergyCache, 'hooks'), { recursive: true });
+
+    // Create mock cache files
+    this.mockCachePaths = [
+      path.join(stigmergyCache, 'config.json'),
+      path.join(stigmergyCache, 'auth.json'),
+      path.join(stigmergyCache, 'error.log'),
+      path.join(stigmergyCache, 'cache', 'cli-cache.json'),
+      path.join(stigmergyCache, 'cache', 'temp-cache.tmp'),
+      path.join(stigmergyCache, 'memory.json')
+    ];
+
+    this.mockCachePaths.forEach(file => {
+      fs.writeFileSync(file, 'mock cache content');
+    });
+
+    // Create mock Stigmergy test directory
+    const stigmergyTest = path.join(this.testDir, '.stigmergy-test');
+    fs.mkdirSync(stigmergyTest, { recursive: true });
+    fs.writeFileSync(path.join(stigmergyTest, 'test-config.json'), '{}');
+
+    // Create mock NPX cache directories
+    const npxCacheBase = path.join(this.testDir, 'npm-cache', '_npx');
+    fs.mkdirSync(npxCacheBase, { recursive: true });
+
+    const npxCacheIds = ['abc123', 'def456', 'ghi789'];
+    npxCacheIds.forEach(id => {
+      const npxCache = path.join(npxCacheBase, id);
+      fs.mkdirSync(npxCache, { recursive: true });
+
+      // Some contain Stigmergy, some don't
+      if (id !== 'def456') {
+        const stigmergyPath = path.join(npxCache, 'node_modules', 'stigmergy');
+        fs.mkdirSync(stigmergyPath, { recursive: true });
+        fs.writeFileSync(path.join(stigmergyPath, 'package.json'), '{}');
+      }
+    });
+
+    // Create mock CLI configuration caches
+    ['claude', 'gemini', 'qwen'].forEach(cli => {
+      const cliConfig = path.join(this.testDir, `.${cli}`);
+      fs.mkdirSync(cliConfig, { recursive: true });
+      fs.mkdirSync(path.join(cliConfig, 'cache'), { recursive: true });
+      fs.writeFileSync(path.join(cliConfig, 'cache', 'stigmergy-cache.json'), '{}');
+      fs.writeFileSync(path.join(cliConfig, 'stigmergy-integration.json'), '{}');
+    });
+
+    // Create temporary files
+    const tempDir = path.join(this.testDir, 'temp');
+    fs.mkdirSync(tempDir, { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'stigmergy-temp.tmp'), 'temp data');
+    fs.writeFileSync(path.join(tempDir, 'stigmergy-lock.lock'), 'lock file');
+
+    console.log('✅ Cache test environment setup complete\n');
+  }
+
+  async testStigmergyCacheCleaning() {
+    console.log('🗂️  TEST 1: Stigmergy Cache Cleaning');
+
+    // Verify Stigmergy cache exists
+    const stigmergyCache = path.join(this.testDir, '.stigmergy');
+    const beforeCleanup = fs.existsSync(stigmergyCache);
+    this.assert(beforeCleanup, 'Stigmergy cache should exist before cleanup');
+
+    // TODO: After implementing CacheCleaner
+    // const cleaner = new CacheCleaner();
+    // const result = await cleaner.cleanStigmergyCache({
+    //   includeConfig: true,
+    //   includeCache: true,
+    //   includeLogs: true
+    // });
+
+    // TODO: Verify cleanup results
+    // this.assert(result.removedFiles > 0, 'Should remove Stigmergy cache files');
+    // this.assert(!fs.existsSync(stigmergyCache), 'Stigmergy cache directory should be removed');
+
+    this.recordResult('Stigmergy Cache Cleaning', '⏳ Pending implementation');
+  }
+
+  async testNPXCacheCleaning() {
+    console.log('📦 TEST 2: NPX Cache Cleaning');
+
+    const npxCacheBase = path.join(this.testDir, 'npm-cache', '_npx');
+    const beforeCleanup = fs.existsSync(npxCacheBase);
+    this.assert(beforeCleanup, 'NPX cache should exist before cleanup');
+
+    // Count Stigmergy entries before cleanup
+    const stigmergyEntriesBefore = this.countStigmergyNPXEntries(npxCacheBase);
+    this.assert(stigmergyEntriesBefore > 0, 'Should have Stigmergy entries in NPX cache');
+
+    // TODO: After implementing NPXCacheCleaner
+    // const cleaner = new NPXCacheCleaner();
+    // const result = await cleaner.cleanStigmergyFromNPXCache({
+    //   dryRun: false,
+    //   force: true
+    // });
+
+    // TODO: Verify cleanup
+    // this.assert(result.removedEntries === stigmergyEntriesBefore,
+    //   'Should remove all Stigmergy entries from NPX cache');
+    // this.assert(fs.existsSync(npxCacheBase), 'Should preserve non-Stigmergy NPX cache');
+
+    this.recordResult('NPX Cache Cleaning', '⏳ Pending implementation');
+  }
+
+  async testNPMCacheCleaning() {
+    console.log('📦 TEST 3: NPM Cache Cleaning');
+
+    // Create mock NPM cache with Stigmergy
+    const npmCache = path.join(this.testDir, 'npm-cache');
+    const npmModules = path.join(npmCache, 'stigmergy-cli', 'node_modules');
+    fs.mkdirSync(npmModules, { recursive: true });
+    fs.writeFileSync(path.join(npmModules, 'stigmergy'), 'mock binary');
+
+    const beforeCleanup = fs.existsSync(npmModules);
+    this.assert(beforeCleanup, 'NPM cache should exist before cleanup');
+
+    // TODO: After implementing NPMCacheCleaner
+    // const cleaner = new NPMCacheCleaner();
+    // const result = await cleaner.cleanNPMCache({
+    //   includeStigmergy: true,
+    //   includeGlobal: false
+    // });
+
+    // TODO: Verify cleanup
+    // this.assert(result.success, 'NPM cache cleaning should succeed');
+    // this.assert(!fs.existsSync(npmModules), 'Stigmergy NPM modules should be removed');
+
+    this.recordResult('NPM Cache Cleaning', '⏳ Pending implementation');
+  }
+
+  async testCLIConfigCacheCleaning() {
+    console.log('⚙️  TEST 4: CLI Configuration Cache Cleaning');
+
+    const cliConfigs = ['claude', 'gemini', 'qwen'];
+    const beforeCleanup = cliConfigs.every(cli => {
+      const cliConfig = path.join(this.testDir, `.${cli}`);
+      return fs.existsSync(cliConfig);
+    });
+    this.assert(beforeCleanup, 'CLI configurations should exist before cleanup');
+
+    // TODO: After implementing CLIConfigCleaner
+    // const cleaner = new CLIConfigCleaner();
+    // const result = await cleaner.cleanCLIConfigurations(cliConfigs, {
+    //   removeStigmergyFiles: true,
+    //   preserveNativeConfig: true
+    // });
+
+    // TODO: Verify cleanup
+    // this.assert(result.cleanedCLIs.length === cliConfigs.length,
+    //   'Should clean all specified CLI configurations');
+    // cliConfigs.forEach(cli => {
+    //   const stigmergyFile = path.join(this.testDir, `.${cli}`, 'stigmergy-integration.json');
+    //   this.assert(!fs.existsSync(stigmergyFile),
+    //     `Should remove Stigmergy files from ${cli} config`);
+    // });
+
+    this.recordResult('CLI Config Cache Cleaning', '⏳ Pending implementation');
+  }
+
+  async testTemporaryFileCleanup() {
+    console.log('🗑️  TEST 5: Temporary File Cleanup');
+
+    const tempDir = path.join(this.testDir, 'temp');
+    const tempFiles = fs.readdirSync(tempDir);
+    this.assert(tempFiles.length > 0, 'Should have temporary files before cleanup');
+
+    // TODO: After implementing TempFileCleaner
+    // const cleaner = new TempFileCleaner();
+    // const result = await cleaner.cleanTemporaryFiles({
+    //   patterns: ['*stigmergy*', '*.tmp', '*.lock'],
+    //   directories: [tempDir, os.tmpdir()]
+    // });
+
+    // TODO: Verify cleanup
+    // this.assert(result.removedFiles.length > 0, 'Should remove temporary files');
+    // const remainingFiles = fs.readdirSync(tempDir).filter(f =>
+    //   f.includes('stigmergy') || f.endsWith('.tmp') || f.endsWith('.lock')
+    // );
+    // this.assert(remainingFiles.length === 0, 'Should remove all Stigmergy temporary files');
+
+    this.recordResult('Temporary File Cleanup', '⏳ Pending implementation');
+  }
+
+  async testSelectiveCacheCleaning() {
+    console.log('🎯 TEST 6: Selective Cache Cleaning');
+
+    // Create selective cache structure
+    const selectiveCache = path.join(this.testDir, '.stigmergy-selective');
+    fs.mkdirSync(selectiveCache, { recursive: true });
+    fs.mkdirSync(path.join(selectiveCache, 'important'), { recursive: true });
+    fs.mkdirSync(path.join(selectiveCache, 'cache'), { recursive: true });
+
+    fs.writeFileSync(path.join(selectiveCache, 'important', 'user-backup.json'), '{}');
+    fs.writeFileSync(path.join(selectiveCache, 'cache', 'auto-cache.tmp'), 'temp');
+
+    // TODO: After implementing selective cleaning
+    // const cleaner = new CacheCleaner();
+    // const result = await cleaner.selectiveClean({
+    //   targetDirectory: selectiveCache,
+    //   preservePatterns: ['**/important/**', '*.backup.json'],
+    //   removePatterns: ['**/cache/**', '*.tmp']
+    // });
+
+    // TODO: Verify selective cleanup
+    // this.assert(fs.existsSync(path.join(selectiveCache, 'important', 'user-backup.json')),
+    //   'Should preserve important files');
+    // this.assert(!fs.existsSync(path.join(selectiveCache, 'cache')),
+    //   'Should remove cache directories');
+
+    this.recordResult('Selective Cache Cleaning', '⏳ Pending implementation');
+  }
+
+  async testCacheCleaningPerformance() {
+    console.log('⚡ TEST 7: Cache Cleaning Performance');
+
+    // Create many small cache files for performance testing
+    const perfCache = path.join(this.testDir, '.stigmergy-perf');
+    fs.mkdirSync(perfCache, { recursive: true });
+
+    for (let i = 0; i < 100; i++) {
+      fs.writeFileSync(path.join(perfCache, `cache-${i}.tmp`), `data ${i}`);
+    }
+
+    const startTime = Date.now();
+
+    // TODO: After implementing performance-optimized cleaner
+    // const cleaner = new CacheCleaner();
+    // const result = await cleaner.cleanWithPerformance({
+    //   targetDirectory: perfCache,
+    //   batchSize: 10,
+    //   parallel: true
+    // });
+
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    // TODO: Verify performance requirements
+    // this.assert(duration < 5000, 'Cache cleaning should complete within 5 seconds');
+    // this.assert(result.removedFiles === 100, 'Should remove all cache files');
+
+    this.recordResult('Cache Cleaning Performance', `⏳ Pending (${duration}ms)`);
+  }
+
+  async testErrorRecovery() {
+    console.log('🛡️  TEST 8: Error Recovery');
+
+    // Test with protected/locked files
+    const protectedFile = path.join(this.testDir, 'protected-stigmergy.lock');
+    fs.writeFileSync(protectedFile, 'protected');
+
+    // Test with non-existent paths
+    const nonExistent = path.join(this.testDir, 'does-not-exist');
+
+    // TODO: After implementing error recovery
+    // const cleaner = new CacheCleaner();
+    //
+    // // Should handle non-existent paths gracefully
+    // const result1 = await cleaner.cleanDirectory(nonExistent);
+    // this.assert(!result1.error, 'Should handle non-existent paths');
+    //
+    // // Should handle permission errors gracefully
+    // const result2 = await cleaner.cleanFile(protectedFile);
+    // this.assert(result2.error, 'Should detect permission errors');
+    // this.assert(result2.action === 'skip', 'Should skip protected files');
+    //
+    // // Should continue processing despite errors
+    // const result3 = await cleaner.batchClean([nonExistent, protectedFile]);
+    // this.assert(result3.processed > 0 || result3.errors.length > 0,
+    //   'Should process batch with mixed results');
+
+    this.recordResult('Error Recovery', '⏳ Pending implementation');
+  }
+
+  countStigmergyNPXEntries(npxCacheBase) {
+    let count = 0;
+    if (fs.existsSync(npxCacheBase)) {
+      const entries = fs.readdirSync(npxCacheBase);
+      entries.forEach(entry => {
+        const stigmergyPath = path.join(npxCacheBase, entry, 'node_modules', 'stigmergy');
+        if (fs.existsSync(stigmergyPath)) {
+          count++;
+        }
+      });
+    }
+    return count;
+  }
+
+  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📊 CACHE CLEANER TEST RESULTS:');
+    console.log('=' .repeat(50));
+
+    this.testResults.forEach(result => {
+      console.log(`${result.status} ${result.name}`);
+    });
+
+    const pending = this.testResults.filter(r => r.status.includes('Pending')).length;
+    const total = this.testResults.length;
+
+    console.log('\n📈 Summary:');
+    console.log(`Total tests: ${total}`);
+    console.log(`Pending implementation: ${pending}`);
+    console.log(`Ready for implementation: ${pending}/${total}`);
+
+    if (pending === total) {
+      console.log('\n🚀 All cache cleaner test cases defined successfully!');
+      console.log('💡 Ready to implement the comprehensive cache cleaning functionality.');
+    }
+  }
+
+  async cleanupTestEnvironment() {
+    console.log('\n🧹 Cleaning up cache test environment...');
+
+    try {
+      fs.rmSync(this.testDir, { recursive: true, force: true });
+      console.log('✅ Cache test environment cleaned up');
+    } catch (error) {
+      console.warn('⚠️  Warning: Could not clean up cache test environment:', error.message);
+    }
+  }
+}
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  const tests = new CacheCleanerTests();
+  tests.runAllTests().catch(console.error);
+}
+
+module.exports = CacheCleanerTests;

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

@@ -0,0 +1,252 @@
+/**
+ * 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;