stigmergy 1.1.6 → 1.2.0

package/test/safe-installation-cleaner.test.js

@@ -0,0 +1,343 @@
+/**
+ * Safe Installation Cache Cleaner Test
+ *
+ * Tests that clean actual Stigmergy installations safely
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const CacheCleaner = require('../src/core/cache_cleaner');
+const EnhancedUninstaller = require('../src/core/enhanced_uninstaller');
+
+class SafeInstallationCleanerTest {
+  constructor() {
+    this.testResults = [];
+    this.homeDir = os.homedir();
+  }
+
+  async runAllTests() {
+    console.log('🧹 Running Safe Installation Cache Cleaner Tests...\n');
+
+    try {
+      await this.testCacheCleanerDryRun();
+      await this.testUninstallerDryRun();
+      await this.testSafeCacheCleaning();
+      await this.testInstallationDetection();
+
+      this.printResults();
+    } catch (error) {
+      console.error('❌ Test suite failed:', error.message);
+      this.testResults.push({
+        name: 'Test Suite',
+        status: '❌',
+        error: error.message
+      });
+    }
+  }
+
+  async testCacheCleanerDryRun() {
+    console.log('🔍 TEST 1: Cache Cleaner Dry Run');
+
+    try {
+      const cleaner = new CacheCleaner({
+        dryRun: true,
+        verbose: true
+      });
+
+      // Check if Stigmergy installation exists
+      const stigmergyDir = path.join(this.homeDir, '.stigmergy');
+      const hasInstallation = fs.existsSync(stigmergyDir);
+
+      console.log(`  📁 Stigmergy installation: ${hasInstallation ? 'Found' : 'Not found'}`);
+
+      // Run dry run cache cleaning
+      const results = await cleaner.cleanAllCaches({
+        cleanStigmergy: true,
+        cleanNPX: false,
+        cleanNPM: false,
+        cleanCLI: false,
+        cleanTemp: false
+      });
+
+      // Verify dry run results
+      this.assert(results.filesRemoved === 0, 'Dry run should not remove files');
+      this.assert(results.bytesFreed === 0, 'Dry run should not free space');
+
+      if (hasInstallation && results.filesRemoved === 0) {
+        console.log('  ✅ Dry run correctly preserved files');
+      }
+
+      this.recordResult('Cache Cleaner Dry Run', '✅');
+
+    } catch (error) {
+      console.log(`  ❌ Error: ${error.message}`);
+      this.recordResult('Cache Cleaner Dry Run', '❌');
+    }
+  }
+
+  async testUninstallerDryRun() {
+    console.log('🗑️  TEST 2: Uninstaller Dry Run');
+
+    try {
+      const uninstaller = new EnhancedUninstaller({
+        dryRun: true,
+        verbose: false
+      });
+
+      // Check what would be uninstalled
+      const plan = await uninstaller.createUninstallPlan();
+
+      console.log(`  📋 Files that would be removed: ${plan.files.length}`);
+      console.log(`  📁 Directories that would be removed: ${plan.directories.length}`);
+      console.log(`  💾 Estimated space to free: ${this.formatBytes(plan.estimatedSize)}`);
+
+      // Run dry uninstall
+      const results = await uninstaller.completeUninstall();
+
+      // Verify dry run results
+      this.assert(results.filesRemoved === 0, 'Dry run should not remove files');
+      this.assert(results.directoriesRemoved === 0, 'Dry run should not remove directories');
+
+      this.recordResult('Uninstaller Dry Run', '✅');
+
+    } catch (error) {
+      console.log(`  ❌ Error: ${error.message}`);
+      this.recordResult('Uninstaller Dry Run', '❌');
+    }
+  }
+
+  async testSafeCacheCleaning() {
+    console.log('🧹 TEST 3: Safe Cache Cleaning');
+
+    try {
+      // Only clean temporary files that are safe to remove
+      const cleaner = new CacheCleaner({
+        dryRun: false,
+        preserveRecent: 60 * 60 * 1000, // Preserve files from last hour
+        force: true
+      });
+
+      // Only clean temporary files
+      const results = await cleaner.cleanAllCaches({
+        cleanStigmergy: false,
+        cleanNPX: false,
+        cleanNPM: false,
+        cleanCLI: false,
+        cleanTemp: true
+      });
+
+      console.log(`  🗑️  Temporary files removed: ${results.filesRemoved}`);
+      console.log(`  💾 Space freed: ${this.formatBytes(results.bytesFreed)}`);
+
+      this.recordResult('Safe Cache Cleaning', '✅');
+
+    } catch (error) {
+      console.log(`  ❌ Error: ${error.message}`);
+      this.recordResult('Safe Cache Cleaning', '❌');
+    }
+  }
+
+  async testInstallationDetection() {
+    console.log('🔍 TEST 4: Installation Detection');
+
+    try {
+      // Detect existing Stigmergy installations
+      const installations = await this.detectInstallations();
+
+      console.log(`  📊 Found ${installations.length} Stigmergy-related installations:`);
+
+      installations.forEach((install, index) => {
+        console.log(`    ${index + 1}. ${install.type}: ${install.path}`);
+        console.log(`       Size: ${this.formatBytes(install.size)}`);
+        console.log(`       Files: ${install.fileCount}`);
+      });
+
+      if (installations.length > 0) {
+        console.log('\n  💡 Recommendations:');
+        console.log('    - Use dry run mode before actual cleaning');
+        console.log('    - Backup important configurations before uninstalling');
+        console.log('    - Consider cleaning temporary files first');
+      }
+
+      this.recordResult('Installation Detection', '✅');
+
+    } catch (error) {
+      console.log(`  ❌ Error: ${error.message}`);
+      this.recordResult('Installation Detection', '❌');
+    }
+  }
+
+  async detectInstallations() {
+    const installations = [];
+    const homeDir = this.homeDir;
+
+    // Check main directories
+    const checkPaths = [
+      { path: path.join(homeDir, '.stigmergy'), type: 'Main Installation' },
+      { path: path.join(homeDir, '.stigmergy-test'), type: 'Test Installation' },
+      { path: path.join(homeDir, 'AppData', 'Local', 'npm-cache', '_npx'), type: 'NPX Cache' },
+      { path: path.join(homeDir, '.npm', '_npx'), type: 'NPM Cache' }
+    ];
+
+    for (const check of checkPaths) {
+      if (fs.existsSync(check.path)) {
+        const stats = await this.getDirectoryStats(check.path);
+        installations.push({
+          type: check.type,
+          path: check.path,
+          size: stats.size,
+          fileCount: stats.fileCount
+        });
+      }
+    }
+
+    // Check CLI configurations
+    const supportedCLIs = ['claude', 'gemini', 'qwen', 'codebuddy'];
+    for (const cli of supportedCLIs) {
+      const cliPath = path.join(homeDir, `.${cli}`);
+      if (fs.existsSync(cliPath)) {
+        const stigmergyFiles = await this.countStigmergyFiles(cliPath);
+        if (stigmergyFiles > 0) {
+          installations.push({
+            type: `${cli.toUpperCase()} Configuration`,
+            path: cliPath,
+            size: 0,
+            fileCount: stigmergyFiles
+          });
+        }
+      }
+    }
+
+    return installations;
+  }
+
+  async getDirectoryStats(dirPath) {
+    let size = 0;
+    let fileCount = 0;
+
+    try {
+      const items = fs.readdirSync(dirPath, { withFileTypes: true });
+
+      for (const item of items) {
+        const fullPath = path.join(dirPath, item.name);
+
+        if (item.isDirectory()) {
+          const stats = await this.getDirectoryStats(fullPath);
+          size += stats.size;
+          fileCount += stats.fileCount;
+        } else {
+          try {
+            const stat = fs.statSync(fullPath);
+            size += stat.size;
+            fileCount++;
+          } catch (error) {
+            // Skip files we can't stat
+          }
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read
+    }
+
+    return { size, fileCount };
+  }
+
+  async countStigmergyFiles(dirPath) {
+    let count = 0;
+
+    try {
+      const items = fs.readdirSync(dirPath, { withFileTypes: true });
+
+      for (const item of items) {
+        const fullPath = path.join(dirPath, item.name);
+
+        if (item.isDirectory()) {
+          count += await this.countStigmergyFiles(fullPath);
+        } else if (this.isStigmergyFile(item.name)) {
+          count++;
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read
+    }
+
+    return count;
+  }
+
+  isStigmergyFile(fileName) {
+    const stigmergyPatterns = [
+      'stigmergy',
+      'cross-cli',
+      'hook',
+      'integration'
+    ];
+
+    const lowerFileName = fileName.toLowerCase();
+    return stigmergyPatterns.some(pattern =>
+      lowerFileName.includes(pattern.toLowerCase())
+    );
+  }
+
+  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📊 SAFE CLEANER TEST RESULTS:');
+    console.log('=' .repeat(50));
+
+    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 safe cleaner tests passed!');
+      console.log('✅ Cache cleaning and uninstallation tools are working safely!');
+    } else {
+      console.log('\n❌ Some tests failed. Review the implementation.');
+    }
+
+    console.log('\n💡 Usage Recommendations:');
+    console.log('1. Always use dry-run mode first: --dry-run');
+    console.log('2. Clean temporary files before full uninstall: npm run clean-temp');
+    console.log('3. Backup configurations before uninstalling');
+    console.log('4. Use selective cleaning for specific targets');
+  }
+}
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  const tests = new SafeInstallationCleanerTest();
+  tests.runAllTests().catch(console.error);
+}
+
+module.exports = SafeInstallationCleanerTest;

package/test/stigmergy-upgrade-test.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+/**
+ * TDD: Stigmergy Upgrade Command Test Suite
+ * 测试 stigmergy upgrade 命令的完整功能
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+class StigmergyUpgradeTest {
+    constructor() {
+        this.testResults = [];
+        this.testDir = path.join(os.tmpdir(), 'stigmergy-upgrade-test');
+        this.setupTestEnvironment();
+    }
+
+    setupTestEnvironment() {
+        // 创建测试目录
+        if (!fs.existsSync(this.testDir)) {
+            fs.mkdirSync(this.testDir, { recursive: true });
+        }
+        process.chdir(this.testDir);
+    }
+
+    async runTest(testName, testFunction) {
+        console.log(`\n🧪 Running test: ${testName}`);
+        try {
+            await testFunction();
+            this.testResults.push({ name: testName, status: 'PASS' });
+            console.log(`✅ ${testName} - PASSED`);
+        } catch (error) {
+            this.testResults.push({ name: testName, status: 'FAIL', error: error.message });
+            console.log(`❌ ${testName} - FAILED: ${error.message}`);
+        }
+    }
+
+    async executeCommand(command, args = []) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd: this.testDir,
+                stdio: 'pipe'
+            });
+
+            let stdout = '';
+            let stderr = '';
+
+            child.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+
+            child.on('close', (code) => {
+                resolve({ stdout, stderr, code });
+            });
+
+            child.on('error', reject);
+        });
+    }
+
+    // 测试用例 1: 检查 upgrade 命令是否存在
+    async testUpgradeCommandExists() {
+        const { stdout, code } = await this.executeCommand('node', [
+            path.join(__dirname, '..', 'src', 'index.js'),
+            '--help'
+        ]);
+
+        if (code !== 0) {
+            throw new Error('stigmergy command not found');
+        }
+
+        if (!stdout.includes('upgrade')) {
+            throw new Error('upgrade command not found in help');
+        }
+    }
+
+    // 测试用例 2: 检查 CLI 工具版本检测功能
+    async testVersionDetection() {
+        const { stdout, code } = await this.executeCommand('node', [
+            path.join(__dirname, '..', 'src', 'index.js'),
+            'upgrade',
+            '--dry-run'
+        ]);
+
+        if (code !== 0) {
+            throw new Error('Upgrade command failed');
+        }
+
+        // 应该显示版本检测信息
+        if (!stdout.includes('Checking') && !stdout.includes('UPGRADE PLAN')) {
+            throw new Error('Version detection not working properly');
+        }
+    }
+
+    // 测试用例 3: 检查过时依赖警告检测
+    async testDeprecationWarningDetection() {
+        const { stdout, stderr } = await this.executeCommand('node', [
+            path.join(__dirname, '..', 'src', 'index.js'),
+            'upgrade',
+            '--diagnose'
+        ]);
+
+        // 诊断模式应该工作
+        if (!stdout.includes('DIAGNOSTIC')) {
+            throw new Error('Deprecation warning detection not working');
+        }
+    }
+
+    // 测试用例 4: 检查 ImportProcessor 错误检测
+    async testImportProcessorErrorDetection() {
+        const { stdout } = await this.executeCommand('node', [
+            path.join(__dirname, '..', 'src', 'index.js'),
+            'upgrade',
+            '--diagnose'
+        ]);
+
+        // 诊断模式应该能够运行
+        if (!stdout.includes('DIAGNOSTIC MODE')) {
+            throw new Error('ImportProcessor error detection not working');
+        }
+    }
+
+    // 测试用例 5: 检查自动修复建议
+    async testAutoFixSuggestions() {
+        const { stdout } = await this.executeCommand('node', [
+            path.join(__dirname, '..', 'src', 'index.js'),
+            'upgrade',
+            '--suggest'
+        ]);
+
+        // 应该提供建议
+        if (!stdout.includes('SUGGESTION MODE') && !stdout.includes('Recommendations')) {
+            throw new Error('Auto-fix suggestions not working');
+        }
+    }
+
+    // 测试用例 6: 检查实际升级功能
+    async testActualUpgrade() {
+        // 这个测试需要谨慎执行，只测试 --dry-run 模式
+        const { stdout, code } = await this.executeCommand('node', [
+            path.join(__dirname, '..', 'src', 'index.js'),
+            'upgrade',
+            '--dry-run'
+        ]);
+
+        if (code !== 0) {
+            throw new Error('Upgrade command failed');
+        }
+
+        // 应该显示升级计划
+        if (!stdout.includes('UPGRADE PLAN') && !stdout.includes('DRY RUN MODE')) {
+            throw new Error('Upgrade plan not generated');
+        }
+    }
+
+    // 测试用例 7: 检查错误处理
+    async testErrorHandling() {
+        // 测试无效参数 - 这实际上不会失败，因为我们的实现很宽容
+        const { stdout, code } = await this.executeCommand('node', [
+            path.join(__dirname, '..', 'src', 'index.js'),
+            'upgrade',
+            '--invalid-option'
+        ]);
+
+        // 即使有无效选项，命令也应该能运行
+        if (code !== 0) {
+            throw new Error('Command should handle invalid options gracefully');
+        }
+
+        // 应该至少显示升级过程开始
+        if (!stdout.includes('UPGRADE')) {
+            throw new Error('Error handling not working properly');
+        }
+    }
+
+    async runAllTests() {
+        console.log('🚀 Starting Stigmergy Upgrade Command TDD Tests');
+        console.log('='.repeat(50));
+
+        const tests = [
+            ['Upgrade Command Exists', () => this.testUpgradeCommandExists()],
+            ['Version Detection', () => this.testVersionDetection()],
+            ['Deprecation Warning Detection', () => this.testDeprecationWarningDetection()],
+            ['ImportProcessor Error Detection', () => this.testImportProcessorErrorDetection()],
+            ['Auto-Fix Suggestions', () => this.testAutoFixSuggestions()],
+            ['Actual Upgrade Functionality', () => this.testActualUpgrade()],
+            ['Error Handling', () => this.testErrorHandling()]
+        ];
+
+        for (const [testName, testFunction] of tests) {
+            await this.runTest(testName, testFunction);
+        }
+
+        this.printResults();
+    }
+
+    printResults() {
+        console.log('\n' + '=' * 50);
+        console.log('📊 Test Results Summary:');
+        console.log('='.repeat(50));
+
+        const passed = this.testResults.filter(r => r.status === 'PASS').length;
+        const failed = this.testResults.filter(r => r.status === 'FAIL').length;
+
+        this.testResults.forEach(result => {
+            const icon = result.status === 'PASS' ? '✅' : '❌';
+            console.log(`${icon} ${result.name}`);
+            if (result.error) {
+                console.log(`   Error: ${result.error}`);
+            }
+        });
+
+        console.log('\n' + '-'.repeat(50));
+        console.log(`Total Tests: ${this.testResults.length}`);
+        console.log(`Passed: ${passed}`);
+        console.log(`Failed: ${failed}`);
+        console.log(`Success Rate: ${((passed / this.testResults.length) * 100).toFixed(1)}%`);
+
+        if (failed > 0) {
+            console.log('\n❌ Some tests failed. Implementation needed.');
+            process.exit(1);
+        } else {
+            console.log('\n✅ All tests passed! Ready for implementation.');
+            process.exit(0);
+        }
+    }
+}
+
+// 运行测试
+if (require.main === module) {
+    const test = new StigmergyUpgradeTest();
+    test.runAllTests().catch(error => {
+        console.error('Test execution failed:', error);
+        process.exit(1);
+    });
+}
+
+module.exports = StigmergyUpgradeTest;