stigmergy 1.1.6 → 1.2.0

package/test/enhanced-uninstaller-implemented.test.js

@@ -0,0 +1,271 @@
+/**
+ * Implementation Tests for Enhanced Stigmergy Uninstaller
+ *
+ * Tests that verify the actual implementation works correctly
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const EnhancedUninstaller = require('../src/core/enhanced_uninstaller');
+
+class EnhancedUninstallerImplementationTests {
+  constructor() {
+    this.testDir = path.join(os.tmpdir(), 'stigmergy-uninstaller-impl-test');
+    this.configDir = path.join(this.testDir, '.stigmergy');
+    this.testConfigDir = path.join(this.testDir, '.stigmergy-test');
+    this.testResults = [];
+  }
+
+  async runAllTests() {
+    console.log('🧪 Running Enhanced Uninstaller Implementation Tests...\n');
+
+    await this.setupTestEnvironment();
+
+    try {
+      await this.testDryRunMode();
+      await this.testCompleteUninstall();
+      await this.testErrorHandling();
+      await this.testDirectoryScanning();
+      await this.testFilePatternMatching();
+
+      this.printResults();
+    } finally {
+      await this.cleanupTestEnvironment();
+    }
+  }
+
+  async setupTestEnvironment() {
+    console.log('📋 Setting up implementation test environment...');
+
+    // Create test directories
+    fs.mkdirSync(this.configDir, { recursive: true });
+    fs.mkdirSync(this.testConfigDir, { recursive: true });
+
+    // Create mock configuration files
+    fs.writeFileSync(path.join(this.configDir, 'config.json'), JSON.stringify({
+      version: '1.1.8',
+      clis: ['claude', 'gemini', 'qwen']
+    }, null, 2));
+
+    fs.writeFileSync(path.join(this.configDir, 'auth.json'), JSON.stringify({
+      tokens: { mock: 'token' }
+    }, null, 2));
+
+    fs.writeFileSync(path.join(this.configDir, 'error.log'), 'Mock error log\n');
+
+    // Create mock hooks directory
+    const hooksDir = path.join(this.configDir, 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+
+    ['claude', 'gemini', 'qwen'].forEach(cli => {
+      const cliHookDir = path.join(hooksDir, cli);
+      fs.mkdirSync(cliHookDir, { recursive: true });
+      fs.writeFileSync(path.join(cliHookDir, `${cli}_nodejs_hook.js`), '// Mock hook');
+      fs.writeFileSync(path.join(cliHookDir, 'config.json'), '{}');
+    });
+
+    console.log('✅ Implementation test environment setup complete\n');
+  }
+
+  async testDryRunMode() {
+    console.log('🔍 TEST 1: Dry Run Mode');
+
+    const uninstaller = new EnhancedUninstaller({
+      dryRun: true,
+      verbose: true
+    });
+
+    // Verify files exist before dry run
+    const configExists = fs.existsSync(this.configDir);
+    this.assert(configExists, 'Test configuration should exist before uninstall');
+
+    // Run dry uninstall
+    const results = await uninstaller.completeUninstall();
+
+    // Verify files still exist after dry run
+    const configStillExists = fs.existsSync(this.configDir);
+    this.assert(configStillExists, 'Configuration should still exist after dry run');
+
+    // Verify dry run detected files
+    this.assert(results.filesRemoved === 0, 'Dry run should not remove files');
+    this.assert(results.directoriesRemoved === 0, 'Dry run should not remove directories');
+
+    this.recordResult('Dry Run Mode', '✅');
+  }
+
+  async testCompleteUninstall() {
+    console.log('🗑️  TEST 2: Complete Uninstall');
+
+    // Recreate test environment
+    await this.setupTestEnvironment();
+
+    const uninstaller = new EnhancedUninstaller({
+      dryRun: false,
+      verbose: false
+    });
+
+    // Verify files exist before uninstall
+    const beforeFiles = [
+      path.join(this.configDir, 'config.json'),
+      path.join(this.configDir, 'auth.json'),
+      path.join(this.configDir, 'error.log'),
+      path.join(this.configDir, 'hooks', 'claude', 'claude_nodejs_hook.js')
+    ];
+
+    const beforeUninstall = beforeFiles.every(file => fs.existsSync(file));
+    this.assert(beforeUninstall, 'Test files should exist before uninstall');
+
+    // Run complete uninstall
+    const results = await uninstaller.completeUninstall();
+
+    // Verify cleanup after uninstall
+    const afterUninstall = !beforeFiles.some(file => fs.existsSync(file));
+    this.assert(afterUninstall, 'All Stigmergy files should be removed after uninstall');
+
+    // Verify results
+    this.assert(results.filesRemoved > 0, 'Should report files removed');
+    this.assert(results.directoriesRemoved >= 0, 'Should report directories removed');
+
+    this.recordResult('Complete Uninstall', '✅');
+  }
+
+  async testErrorHandling() {
+    console.log('⚠️  TEST 3: Error Handling');
+
+    const uninstaller = new EnhancedUninstaller({
+      force: true,
+      dryRun: true
+    });
+
+    // Test with non-existent directory
+    const nonExistentPath = path.join(this.testDir, 'does-not-exist');
+
+    // Should handle missing directory gracefully
+    const plan = await uninstaller.createUninstallPlan();
+
+    // Should not crash on missing directories
+    this.assert(plan !== undefined, 'Should handle missing directories gracefully');
+
+    // Test uninstall with non-existent paths
+    const results = await uninstaller.completeUninstall();
+
+    // Should not report errors for non-existent files in dry run
+    this.assert(Array.isArray(results.errors), 'Should return error array');
+
+    this.recordResult('Error Handling', '✅');
+  }
+
+  async testDirectoryScanning() {
+    console.log('📁 TEST 4: Directory Scanning');
+
+    // Create a more complex directory structure
+    const complexDir = path.join(this.testDir, '.stigmergy-complex');
+    fs.mkdirSync(complexDir, { recursive: true });
+
+    fs.mkdirSync(path.join(complexDir, 'subdir1'), { recursive: true });
+    fs.mkdirSync(path.join(complexDir, 'subdir2'), { recursive: true });
+
+    fs.writeFileSync(path.join(complexDir, 'file1.txt'), 'content');
+    fs.writeFileSync(path.join(complexDir, 'subdir1', 'file2.txt'), 'content');
+    fs.writeFileSync(path.join(complexDir, 'subdir2', 'file3.txt'), 'content');
+
+    const uninstaller = new EnhancedUninstaller({ dryRun: true });
+
+    // Test plan creation
+    const plan = await uninstaller.createUninstallPlan();
+
+    // Should scan directories correctly
+    this.assert(plan.files.length > 0, 'Should find files in directory scan');
+    this.assert(plan.directories.length > 0, 'Should find directories in scan');
+
+    // Clean up
+    fs.rmSync(complexDir, { recursive: true, force: true });
+
+    this.recordResult('Directory Scanning', '✅');
+  }
+
+  async testFilePatternMatching() {
+    console.log('🎯 TEST 5: File Pattern Matching');
+
+    const uninstaller = new EnhancedUninstaller({ dryRun: true });
+
+    // Test internal pattern matching methods
+    const testFiles = [
+      'stigmergy-config.json',
+      'cross-cli-hook.js',
+      'integration-settings.json',
+      'cache-data.tmp',
+      'normal-file.txt'
+    ];
+
+    // Test if methods exist and work
+    let stigmergyFilesFound = 0;
+
+    for (const fileName of testFiles) {
+      if (uninstaller.isStigmergyFile && uninstaller.isStigmergyFile(fileName)) {
+        stigmergyFilesFound++;
+      }
+    }
+
+    this.assert(stigmergyFilesFound >= 4, 'Should identify Stigmergy files correctly');
+
+    this.recordResult('File Pattern Matching', '✅');
+  }
+
+  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📊 IMPLEMENTATION TEST RESULTS:');
+    console.log('=' .repeat(50));
+
+    this.testResults.forEach(result => {
+      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 implementation tests passed!');
+      console.log('✅ Enhanced uninstaller is working correctly!');
+    } else {
+      console.log('\n❌ Some tests failed. Review the implementation.');
+    }
+  }
+
+  async cleanupTestEnvironment() {
+    console.log('\n🧹 Cleaning up implementation test environment...');
+
+    try {
+      fs.rmSync(this.testDir, { recursive: true, force: true });
+      console.log('✅ Implementation test environment cleaned up');
+    } catch (error) {
+      console.warn('⚠️  Warning: Could not clean up test environment:', error.message);
+    }
+  }
+}
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  const tests = new EnhancedUninstallerImplementationTests();
+  tests.runAllTests().catch(console.error);
+}
+
+module.exports = EnhancedUninstallerImplementationTests;

package/test/enhanced-uninstaller.test.js

@@ -0,0 +1,284 @@
+/**
+ * TDD Tests for Enhanced Stigmergy Uninstaller
+ *
+ * Test-first approach to ensure complete cleanup of Stigmergy installation
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+class EnhancedUninstallerTests {
+  constructor() {
+    this.testDir = path.join(os.tmpdir(), 'stigmergy-uninstaller-test');
+    this.configDir = path.join(this.testDir, '.stigmergy');
+    this.testConfigDir = path.join(this.testDir, '.stigmergy-test');
+    this.npmCacheDir = path.join(this.testDir, 'npm-cache');
+    this.testResults = [];
+  }
+
+  async runAllTests() {
+    console.log('🧪 Running Enhanced Uninstaller TDD Tests...\n');
+
+    await this.setupTestEnvironment();
+
+    try {
+      await this.testCompleteUninstall();
+      await this.testCacheCleaning();
+      await this.testNPXCacheCleaning();
+      await this.testCLIConfigCleanup();
+      await this.testErrorHandling();
+      await this.testDryRunMode();
+
+      this.printResults();
+    } finally {
+      await this.cleanupTestEnvironment();
+    }
+  }
+
+  async setupTestEnvironment() {
+    console.log('📋 Setting up test environment...');
+
+    // Create test directories
+    fs.mkdirSync(this.configDir, { recursive: true });
+    fs.mkdirSync(this.testConfigDir, { recursive: true });
+    fs.mkdirSync(this.npmCacheDir, { recursive: true });
+
+    // Create mock configuration files
+    fs.writeFileSync(path.join(this.configDir, 'config.json'), JSON.stringify({
+      version: '1.1.8',
+      clis: ['claude', 'gemini', 'qwen']
+    }, null, 2));
+
+    fs.writeFileSync(path.join(this.configDir, 'auth.json'), JSON.stringify({
+      tokens: { mock: 'token' }
+    }, null, 2));
+
+    fs.writeFileSync(path.join(this.configDir, 'error.log'), 'Mock error log\n');
+
+    // Create mock hooks directory
+    const hooksDir = path.join(this.configDir, 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+
+    ['claude', 'gemini', 'qwen'].forEach(cli => {
+      const cliHookDir = path.join(hooksDir, cli);
+      fs.mkdirSync(cliHookDir, { recursive: true });
+      fs.writeFileSync(path.join(cliHookDir, `${cli}_nodejs_hook.js`), '// Mock hook');
+      fs.writeFileSync(path.join(cliHookDir, 'config.json'), '{}');
+    });
+
+    // Create mock CLI config directories
+    ['claude', 'gemini', 'qwen'].forEach(cli => {
+      const cliConfig = path.join(this.testDir, `.${cli}`);
+      fs.mkdirSync(cliConfig, { recursive: true });
+      fs.writeFileSync(path.join(cliConfig, 'stigmergy-config.json'), '{}');
+    });
+
+    // Create mock npm cache files
+    const npxCacheDir = path.join(this.npmCacheDir, '_npx');
+    fs.mkdirSync(npxCacheDir, { recursive: true });
+    fs.mkdirSync(path.join(npxCacheDir, 'mock-cache-id'), { recursive: true });
+
+    console.log('✅ Test environment setup complete\n');
+  }
+
+  async testCompleteUninstall() {
+    console.log('🔍 TEST 1: Complete Uninstall Functionality');
+
+    const expectedFiles = [
+      path.join(this.configDir, 'config.json'),
+      path.join(this.configDir, 'auth.json'),
+      path.join(this.configDir, 'error.log'),
+      path.join(this.configDir, 'hooks', 'claude', 'claude_nodejs_hook.js')
+    ];
+
+    // Verify test files exist before uninstall
+    const beforeUninstall = expectedFiles.every(file => fs.existsSync(file));
+    this.assert(beforeUninstall, 'Test files should exist before uninstall');
+
+    // TODO: After implementing EnhancedUninstaller, call it here
+    // const uninstaller = new EnhancedUninstaller();
+    // await uninstaller.completeUninstall({ dryRun: false, testMode: true });
+
+    // TODO: Verify cleanup after uninstall
+    // const afterUninstall = !expectedFiles.some(file => fs.existsSync(file));
+    // this.assert(afterUninstall, 'All Stigmergy files should be removed after uninstall');
+
+    this.recordResult('Complete Uninstall', '⏳ Pending implementation');
+  }
+
+  async testCacheCleaning() {
+    console.log('🧹 TEST 2: Cache Cleaning Functionality');
+
+    // Mock cache files
+    const cacheFiles = [
+      path.join(this.configDir, 'cache', 'test-cache.json'),
+      path.join(this.configDir, 'memory.json')
+    ];
+
+    cacheFiles.forEach(file => {
+      const dir = path.dirname(file);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(file, 'mock cache data');
+    });
+
+    // Verify cache files exist
+    const beforeCleanup = cacheFiles.every(file => fs.existsSync(file));
+    this.assert(beforeCleanup, 'Cache files should exist before cleanup');
+
+    // TODO: After implementing cache cleaner
+    // const cleaner = new CacheCleaner();
+    // await cleaner.cleanAllCaches({ includeStigmergy: true, includeNPM: false });
+
+    // TODO: Verify cache files are removed
+    // const afterCleanup = !cacheFiles.some(file => fs.existsSync(file));
+    // this.assert(afterCleanup, 'Cache files should be removed after cleanup');
+
+    this.recordResult('Cache Cleaning', '⏳ Pending implementation');
+  }
+
+  async testNPXCacheCleaning() {
+    console.log('📦 TEST 3: NPX Cache Cleaning');
+
+    // Create mock npx cache
+    const npxCachePath = path.join(this.npmCacheDir, '_npx', 'test-cache-id', 'node_modules', 'stigmergy');
+    fs.mkdirSync(npxCachePath, { recursive: true });
+    fs.writeFileSync(path.join(npxCachePath, 'package.json'), '{}');
+
+    // Verify npx cache exists
+    const beforeCleanup = fs.existsSync(npxCachePath);
+    this.assert(beforeCleanup, 'NPX cache should exist before cleanup');
+
+    // TODO: After implementing NPX cache cleaner
+    // const cleaner = new NPXCacheCleaner();
+    // const removed = await cleaner.cleanStigmergyFromNPXCache();
+    // this.assert(removed > 0, 'Should remove Stigmergy from NPX cache');
+
+    this.recordResult('NPX Cache Cleaning', '⏳ Pending implementation');
+  }
+
+  async testCLIConfigCleanup() {
+    console.log('⚙️  TEST 4: CLI Configuration Cleanup');
+
+    const cliConfigs = ['claude', 'gemini', 'qwen'].map(cli => ({
+      cli,
+      configPath: path.join(this.testDir, `.${cli}`, 'stigmergy-config.json'),
+      hooksPath: path.join(this.testDir, `.${cli}`, 'hooks', 'stigmergy')
+    }));
+
+    // Create mock CLI hooks
+    cliConfigs.forEach(config => {
+      fs.mkdirSync(path.dirname(config.hooksPath), { recursive: true });
+      fs.writeFileSync(config.hooksPath, '// mock hook');
+    });
+
+    // Verify CLI configs exist
+    const beforeCleanup = cliConfigs.every(config =>
+      fs.existsSync(config.configPath) || fs.existsSync(config.hooksPath)
+    );
+    this.assert(beforeCleanup, 'CLI configurations should exist before cleanup');
+
+    // TODO: After implementing CLI config cleaner
+    // const cleaner = new CLIConfigCleaner();
+    // const results = await cleaner.cleanCLIConfigurations(['claude', 'gemini', 'qwen']);
+    // this.assert(results.cleaned > 0, 'Should clean CLI configurations');
+
+    this.recordResult('CLI Config Cleanup', '⏳ Pending implementation');
+  }
+
+  async testErrorHandling() {
+    console.log('⚠️  TEST 5: Error Handling');
+
+    // Test with non-existent directory
+    const nonExistentPath = path.join(this.testDir, 'does-not-exist');
+
+    // TODO: Test error handling for various scenarios
+    // const uninstaller = new EnhancedUninstaller();
+
+    // Should handle missing directory gracefully
+    // const result1 = await uninstaller.removeDirectory(nonExistentPath);
+    // this.assert(!result1.error, 'Should handle missing directory gracefully');
+
+    // Should handle permission denied gracefully
+    // const result2 = await uninstaller.removeDirectory('/root/protected');
+    // this.assert(result2.error, 'Should detect permission errors');
+
+    this.recordResult('Error Handling', '⏳ Pending implementation');
+  }
+
+  async testDryRunMode() {
+    console.log('🔍 TEST 6: Dry Run Mode');
+
+    // Create files that should be preserved in dry run
+    const testFile = path.join(this.configDir, 'should-preserve.txt');
+    fs.writeFileSync(testFile, 'preserve me');
+
+    // TODO: Test dry run functionality
+    // const uninstaller = new EnhancedUninstaller();
+    // const plan = await uninstaller.createUninstallPlan({ dryRun: true });
+
+    // Should return what would be deleted
+    // this.assert(plan.files.length > 0, 'Should identify files to delete');
+
+    // Should not actually delete files in dry run
+    // const stillExists = fs.existsSync(testFile);
+    // this.assert(stillExists, 'Files should not be deleted in dry run mode');
+
+    this.recordResult('Dry Run Mode', '⏳ Pending implementation');
+  }
+
+  async cleanupTestEnvironment() {
+    console.log('\n🧹 Cleaning up test environment...');
+
+    try {
+      fs.rmSync(this.testDir, { recursive: true, force: true });
+      console.log('✅ Test environment cleaned up');
+    } catch (error) {
+      console.warn('⚠️  Warning: Could not clean up test environment:', error.message);
+    }
+  }
+
+  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📊 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 test cases defined successfully!');
+      console.log('💡 Ready to implement the enhanced uninstaller functionality.');
+    }
+  }
+}
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  const tests = new EnhancedUninstallerTests();
+  tests.runAllTests().catch(console.error);
+}
+
+module.exports = EnhancedUninstallerTests;

package/test/plugin-deployment-test.js

@@ -29,7 +29,7 @@ const CLI_TOOLS = {
     qwen: {
         name: 'Qwen CLI',
         version: 'qwen --version',
-        install: 'npm install -g @alibaba/qwen-cli',
+        install: 'npm install -g @qwen-code/qwen-code',
         hooksDir: path.join(os.homedir(), '.qwen', 'hooks'),
         config: path.join(os.homedir(), '.qwen', 'config.json')
     },