stigmergy 1.1.6 → 1.2.6

package/test/collision-test.js

@@ -1,26 +0,0 @@
-const { HashTable } = require('../src/utils');
-
-console.log("=== Hash Table Collision Handling Demo ===");
-
-// Create a hash table with a small size to force collisions
-const ht = new HashTable(4); // Small size to demonstrate collisions
-
-// Add several key-value pairs that will cause collisions
-ht.set("key1", "value1");
-ht.set("key2", "value2");
-ht.set("key3", "value3");
-ht.set("key4", "value4");
-ht.set("key5", "value5"); // This will collide with one of the above
-
-console.log("Values retrieved:");
-console.log("key1:", ht.get("key1"));
-console.log("key2:", ht.get("key2"));
-console.log("key3:", ht.get("key3"));
-console.log("key4:", ht.get("key4"));
-console.log("key5:", ht.get("key5"));
-console.log("nonexistent_key:", ht.get("nonexistent_key"));
-
-console.log("\nAll keys:", ht.keys());
-console.log("All values:", ht.values());
-
-console.log("\n=== Test completed successfully! ===");

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);
-    });
-}

package/test/conflict-prevention-test.js

@@ -1,95 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Stigmergy Conflict Prevention System Test
- * This script verifies that the conflict prevention system works correctly
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { spawn } = require('child_process');
-
-async function runTests() {
-    console.log('Stigmergy Conflict Prevention System Test');
-    console.log('='.repeat(50));
-    
-    let passedTests = 0;
-    let totalTests = 0;
-    
-    // Test 1: Pre-installation check exists
-    totalTests++;
-    try {
-        await fs.access(path.join(__dirname, '..', 'scripts', 'preinstall-check.js'));
-        console.log('[PASS] Test 1: Pre-installation check script exists');
-        passedTests++;
-    } catch (error) {
-        console.log('[FAIL] Test 1: Pre-installation check script missing');
-    }
-    
-    // Test 2: Conflict fixer exists
-    totalTests++;
-    try {
-        await fs.access(path.join(__dirname, '..', 'fix-node-conflict.js'));
-        console.log('[PASS] Test 2: Conflict fixer script exists');
-        passedTests++;
-    } catch (error) {
-        console.log('[FAIL] Test 2: Conflict fixer script missing');
-    }
-    
-    // Test 3: Safety check in main script
-    totalTests++;
-    try {
-        const mainScript = await fs.readFile(path.join(__dirname, '..', 'src', 'main_english.js'), 'utf8');
-        if (mainScript.includes('safetyCheck')) {
-            console.log('[PASS] Test 3: Safety check implemented in main script');
-            passedTests++;
-        } else {
-            console.log('[FAIL] Test 3: Safety check not found in main script');
-        }
-    } catch (error) {
-        console.log('[FAIL] Test 3: Could not read main script');
-    }
-    
-    // Test 4: Package.json includes safety scripts
-    totalTests++;
-    try {
-        const packageJson = JSON.parse(await fs.readFile(path.join(__dirname, '..', 'package.json'), 'utf8'));
-        if (packageJson.scripts && packageJson.scripts['fix-node-conflict']) {
-            console.log('[PASS] Test 4: Safety scripts registered in package.json');
-            passedTests++;
-        } else {
-            console.log('[FAIL] Test 4: Safety scripts missing from package.json');
-        }
-    } catch (error) {
-        console.log('[FAIL] Test 4: Could not read package.json');
-    }
-    
-    // Test 5: Documentation exists
-    totalTests++;
-    try {
-        await fs.access(path.join(__dirname, '..', 'docs', 'CONFLICT_PREVENTION.md'));
-        console.log('[PASS] Test 5: Conflict prevention documentation exists');
-        passedTests++;
-    } catch (error) {
-        console.log('[FAIL] Test 5: Conflict prevention documentation missing');
-    }
-    
-    console.log('\n' + '='.repeat(50));
-    console.log(`Test Results: ${passedTests}/${totalTests} tests passed`);
-    
-    if (passedTests === totalTests) {
-        console.log('[SUCCESS] All conflict prevention mechanisms are in place!');
-        return true;
-    } else {
-        console.log('[WARNING] Some conflict prevention mechanisms are missing.');
-        return false;
-    }
-}
-
-// Run tests
-runTests().then(success => {
-    process.exit(success ? 0 : 1);
-}).catch(error => {
-    console.error('[ERROR] Test suite failed:', error.message);
-    process.exit(1);
-});

package/test/cross-cli-detection-test.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-
-// Test the cross-CLI detection functionality
-const fs = require('fs');
-const path = require('path');
-
-// Load the generated hook
-const hookPath = path.join(process.env.HOME || process.env.USERPROFILE, '.stigmergy', 'hooks', 'claude', 'claude_nodejs_hook.js');
-
-if (fs.existsSync(hookPath)) {
-  const ClaudeHook = require(hookPath);
-  const hook = new ClaudeHook();
-  
-  console.log('Testing cross-CLI detection...');
-  
-  // Test cases
-  const testCases = [
-    'use gemini to generate a python function',
-    'call qwencode to refactor this code',
-    'ask codex for help with javascript',
-    'please help me with this task', // Should not match
-    'use copilot to write a test'    // Should match
-  ];
-  
-  testCases.forEach(testCase => {
-    const result = hook.detectCrossCLIRequest(testCase);
-    console.log(`Input: "${testCase}"`);
-    console.log(`Result:`, result ? JSON.stringify(result, null, 2) : 'No match');
-    console.log('---');
-  });
-} else {
-  console.log('Hook file not found at:', hookPath);
-}

package/test/csv-processing-test.js

@@ -1,36 +0,0 @@
-const { processCSV } = require('../src/utils');
-
-// Test basic CSV processing
-console.log('Testing basic CSV processing...');
-
-const csvData = `name,age,city
-John,25,New York
-Jane,30,Boston
-Bob,35,Chicago
-Alice,28,Los Angeles`;
-
-const stats = processCSV(csvData);
-console.log('Basic CSV Stats:', JSON.stringify(stats, null, 2));
-
-// Test CSV without headers
-console.log('\nTesting CSV without headers...');
-
-const csvWithoutHeaders = `John,25,New York
-Jane,30,Boston
-Bob,35,Chicago`;
-
-const statsNoHeaders = processCSV(csvWithoutHeaders, { hasHeader: false });
-console.log('CSV without headers Stats:', JSON.stringify(statsNoHeaders, null, 2));
-
-// Test CSV with numeric data
-console.log('\nTesting CSV with numeric data...');
-
-const csvNumeric = `product,price,quantity
-Apple,1.20,100
-Banana,0.50,200
-Orange,0.80,150`;
-
-const statsNumeric = processCSV(csvNumeric);
-console.log('Numeric CSV Stats:', JSON.stringify(statsNumeric, null, 2));
-
-console.log('\nCSV processing tests completed successfully!');