stigmergy 1.0.88 → 1.0.92

package/test/iflow-integration-test.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+
+/**
+ * iFlow Stigmergy Integration Test
+ * This script tests if iFlow can properly detect and use Stigmergy hooks
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+class IFlowIntegrationTester {
+    constructor() {
+        this.iflowConfigDir = path.join(os.homedir(), '.iflow');
+        this.iflowHooksDir = path.join(this.iflowConfigDir, 'hooks');
+    }
+    
+    // Check if iFlow config directory exists
+    async checkIFlowConfig() {
+        try {
+            await fs.access(this.iflowConfigDir);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+    
+    // Check if iFlow hooks directory exists and has Stigmergy files
+    async checkIFlowHooks() {
+        try {
+            await fs.access(this.iflowHooksDir);
+            const files = await fs.readdir(this.iflowHooksDir);
+            const stigmergyFiles = files.filter(file => 
+                file.includes('stigmergy') || 
+                file.includes('Stigmergy') ||
+                file.includes('hook') ||
+                file.includes('adapter')
+            );
+            
+            return {
+                exists: true,
+                files: files,
+                stigmergyFiles: stigmergyFiles,
+                path: this.iflowHooksDir
+            };
+        } catch (error) {
+            return {
+                exists: false,
+                files: [],
+                stigmergyFiles: [],
+                path: this.iflowHooksDir
+            };
+        }
+    }
+    
+    // Check if iFlow has hooks configuration
+    async checkIFlowHooksConfig() {
+        // Check multiple possible config locations
+        const configLocations = [
+            path.join(os.homedir(), '.config', 'iflow', 'hooks.yml'),
+            path.join(os.homedir(), '.config', 'iflow', 'hooks.yaml'),
+            path.join(os.homedir(), '.iflow', 'hooks.yml'),
+            path.join(os.homedir(), '.iflow', 'hooks.yaml'),
+            path.join(os.homedir(), '.iflow', 'config.yml'),
+            path.join(os.homedir(), '.iflow', 'settings.json')
+        ];
+        
+        for (const configFile of configLocations) {
+            try {
+                await fs.access(configFile);
+                const content = await fs.readFile(configFile, 'utf8');
+                if (content.includes('hooks') || content.includes('plugins') || content.includes('CrossCLIHookAdapter')) {
+                    return {
+                        exists: true,
+                        path: configFile,
+                        hasHooksSection: true,
+                        contentPreview: content.substring(0, 200)
+                    };
+                }
+            } catch (error) {
+                // File doesn't exist, continue to next
+            }
+        }
+        
+        return {
+            exists: false,
+            path: null,
+            hasHooksSection: false,
+            contentPreview: ''
+        };
+    }
+    
+    // Test iFlow hooks command
+    async testIFlowHooksCommand() {
+        return new Promise((resolve) => {
+            const child = spawn('iflow', ['hooks'], {
+                stdio: 'pipe',
+                timeout: 10000
+            });
+            
+            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({
+                    success: code === 0,
+                    code: code,
+                    stdout: stdout,
+                    stderr: stderr,
+                    output: stdout + stderr
+                });
+            });
+            
+            child.on('error', (error) => {
+                resolve({
+                    success: false,
+                    error: error.message,
+                    stdout: '',
+                    stderr: '',
+                    output: ''
+                });
+            });
+        });
+    }
+    
+    // Test iFlow plugin command
+    async testIFlowPluginCommand() {
+        return new Promise((resolve) => {
+            const child = spawn('iflow', ['plugins'], {
+                stdio: 'pipe',
+                timeout: 10000
+            });
+            
+            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({
+                    success: code === 0,
+                    code: code,
+                    stdout: stdout,
+                    stderr: stderr,
+                    output: stdout + stderr
+                });
+            });
+            
+            child.on('error', (error) => {
+                resolve({
+                    success: false,
+                    error: error.message,
+                    stdout: '',
+                    stderr: '',
+                    output: ''
+                });
+            });
+        });
+    }
+    
+    // Run comprehensive iFlow integration test
+    async runIntegrationTest() {
+        console.log('iFlow Stigmergy Integration Test');
+        console.log('='.repeat(40));
+        
+        // Test 1: Check iFlow configuration
+        console.log('\n[Test 1] Checking iFlow configuration...');
+        const configExists = await this.checkIFlowConfig();
+        console.log(`  Config directory exists: ${configExists ? '✓' : '✗'}`);
+        
+        // Test 2: Check iFlow hooks directory
+        console.log('\n[Test 2] Checking iFlow hooks directory...');
+        const hooksInfo = await this.checkIFlowHooks();
+        console.log(`  Hooks directory exists: ${hooksInfo.exists ? '✓' : '✗'}`);
+        console.log(`  Total files: ${hooksInfo.files.length}`);
+        console.log(`  Stigmergy-related files: ${hooksInfo.stigmergyFiles.length}`);
+        if (hooksInfo.stigmergyFiles.length > 0) {
+            console.log('  Stigmergy files found:');
+            hooksInfo.stigmergyFiles.forEach(file => console.log(`    - ${file}`));
+        }
+        
+        // Test 3: Check hooks configuration
+        console.log('\n[Test 3] Checking hooks configuration...');
+        const hooksConfig = await this.checkIFlowHooksConfig();
+        console.log(`  Config file exists: ${hooksConfig.exists ? '✓' : '✗'}`);
+        console.log(`  Has hooks section: ${hooksConfig.hasHooksSection ? '✓' : '✗'}`);
+        
+        // Test 4: Test iFlow hooks command
+        console.log('\n[Test 4] Testing iFlow hooks command...');
+        const hooksCommandResult = await this.testIFlowHooksCommand();
+        console.log(`  Command success: ${hooksCommandResult.success ? '✓' : '✗'}`);
+        console.log(`  Exit code: ${hooksCommandResult.code}`);
+        if (hooksCommandResult.output) {
+            const preview = hooksCommandResult.output.substring(0, 200);
+            console.log(`  Output preview: ${preview}${hooksCommandResult.output.length > 200 ? '...' : ''}`);
+            
+            // Check if Stigmergy is mentioned in output
+            if (hooksCommandResult.output.toLowerCase().includes('stigmergy')) {
+                console.log('  ✓ Stigmergy detected in hooks output');
+            } else {
+                console.log('  ✗ Stigmergy not detected in hooks output');
+            }
+        }
+        
+        // Test 5: Test iFlow plugin command
+        console.log('\n[Test 5] Testing iFlow plugin command...');
+        const pluginCommandResult = await this.testIFlowPluginCommand();
+        console.log(`  Command success: ${pluginCommandResult.success ? '✓' : '✗'}`);
+        console.log(`  Exit code: ${pluginCommandResult.code}`);
+        if (pluginCommandResult.output) {
+            const preview = pluginCommandResult.output.substring(0, 200);
+            console.log(`  Output preview: ${preview}${pluginCommandResult.output.length > 200 ? '...' : ''}`);
+            
+            // Check if Stigmergy is mentioned in output
+            if (pluginCommandResult.output.toLowerCase().includes('stigmergy')) {
+                console.log('  ✓ Stigmergy detected in plugins output');
+            } else {
+                console.log('  ✗ Stigmergy not detected in plugins output');
+            }
+        }
+        
+        // Summary
+        console.log('\n' + '='.repeat(40));
+        console.log('Integration Test Summary:');
+        console.log('='.repeat(40));
+        
+        const results = {
+            configExists,
+            hooksDirectoryExists: hooksInfo.exists,
+            stigmergyHooksPresent: hooksInfo.stigmergyFiles.length > 0,
+            hooksCommandWorks: hooksCommandResult.success,
+            pluginsCommandWorks: pluginCommandResult.success,
+            stigmergyDetectedInHooks: hooksCommandResult.output.toLowerCase().includes('stigmergy'),
+            stigmergyDetectedInPlugins: pluginCommandResult.output.toLowerCase().includes('stigmergy')
+        };
+        
+        Object.entries(results).forEach(([test, result]) => {
+            console.log(`${test}: ${result ? '✓ PASS' : '✗ FAIL'}`);
+        });
+        
+        const passedTests = Object.values(results).filter(Boolean).length;
+        const totalTests = Object.values(results).length;
+        
+        console.log(`\nOverall Result: ${passedTests}/${totalTests} tests passed`);
+        
+        if (passedTests === totalTests) {
+            console.log('✓ iFlow Stigmergy integration is working correctly!');
+        } else if (passedTests > 0) {
+            console.log('⚠ iFlow Stigmergy integration is partially working.');
+        } else {
+            console.log('✗ iFlow Stigmergy integration is not working.');
+        }
+        
+        return results;
+    }
+}
+
+// Run the test
+async function runIFlowIntegrationTest() {
+    const tester = new IFlowIntegrationTester();
+    const results = await tester.runIntegrationTest();
+    
+    return results;
+}
+
+// Export for use in other modules
+module.exports = { IFlowIntegrationTester };
+
+// Run if called directly
+if (require.main === module) {
+    runIFlowIntegrationTest().then(results => {
+        process.exit(0);
+    }).catch(error => {
+        console.error('[Test Failed]:', error.message);
+        process.exit(1);
+    });
+}

package/test/improved-install-test.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+
+/**
+ * Improved Test for CLI Installation with Better Error Handling
+ * This test verifies installation commands with improved error handling
+ * and Windows compatibility
+ */
+
+const { spawnSync, spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+
+class ImprovedInstallTester {
+    constructor() {
+        this.testResults = [];
+    }
+    
+    // Test 1: Verify npm availability with multiple methods
+    async testNpmAvailability() {
+        console.log('[TEST 1] Verifying npm availability with multiple methods...');
+        
+        try {
+            // Method 1: Direct npm command
+            console.log('  Testing direct npm command...');
+            const npmDirect = spawnSync('npm', ['--version'], {
+                encoding: 'utf8',
+                timeout: 10000
+            });
+            
+            console.log(`  Direct npm - Status: ${npmDirect.status}`);
+            if (npmDirect.stdout) {
+                console.log(`  Direct npm - Version: ${npmDirect.stdout.trim()}`);
+            }
+            
+            // Method 2: npm through cmd.exe on Windows
+            const isWindows = process.platform === 'win32';
+            let npmThroughCmd = { status: null };
+            
+            if (isWindows) {
+                console.log('  Testing npm through cmd.exe...');
+                npmThroughCmd = spawnSync('cmd.exe', ['/c', 'npm', '--version'], {
+                    encoding: 'utf8',
+                    timeout: 10000
+                });
+                console.log(`  npm through cmd.exe - Status: ${npmThroughCmd.status}`);
+            }
+            
+            // Method 3: Check PATH for npm
+            console.log('  Checking PATH for npm...');
+            const pathEnv = process.env.PATH || '';
+            const hasNpmInPath = pathEnv.toLowerCase().includes('npm');
+            console.log(`  npm in PATH: ${hasNpmInPath}`);
+            
+            const npmAvailable = npmDirect.status === 0 || npmThroughCmd.status === 0;
+            
+            this.testResults.push({
+                name: 'npm Availability',
+                passed: npmAvailable,
+                details: `Direct: ${npmDirect.status === 0}, Cmd: ${npmThroughCmd.status === 0}, PATH: ${hasNpmInPath}`
+            });
+            
+            return npmAvailable;
+        } catch (error) {
+            console.log(`  ✗ Failed to check npm availability: ${error.message}`);
+            this.testResults.push({
+                name: 'npm Availability',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 2: Test Qoder CLI installation with shell options
+    async testQoderInstallationWithShellOptions() {
+        console.log('\n[TEST 2] Testing Qoder CLI installation with shell options...');
+        
+        try {
+            const installCommand = 'npm install -g @qoder-ai/qodercli';
+            const commandParts = installCommand.split(' ');
+            const command = commandParts[0];
+            const args = commandParts.slice(1);
+            
+            console.log(`  Installation command: ${installCommand}`);
+            
+            // Test 1: Without shell option
+            console.log('  Testing without shell option...');
+            const test1 = spawnSync(command, args, {
+                encoding: 'utf8',
+                timeout: 15000,
+                stdio: 'pipe'
+            });
+            
+            console.log(`  Without shell - Status: ${test1.status}`);
+            
+            // Test 2: With shell=true
+            console.log('  Testing with shell=true...');
+            const test2 = spawnSync(command, args, {
+                encoding: 'utf8',
+                timeout: 15000,
+                stdio: 'pipe',
+                shell: true
+            });
+            
+            console.log(`  With shell - Status: ${test2.status}`);
+            
+            // Test 3: On Windows, try cmd.exe explicitly
+            let test3 = { status: null };
+            if (process.platform === 'win32') {
+                console.log('  Testing with explicit cmd.exe...');
+                const fullCommand = [command, ...args].join(' ');
+                test3 = spawnSync('cmd.exe', ['/c', fullCommand], {
+                    encoding: 'utf8',
+                    timeout: 15000,
+                    stdio: 'pipe'
+                });
+                console.log(`  Explicit cmd.exe - Status: ${test3.status}`);
+            }
+            
+            // Determine which method works
+            const worksWithoutShell = test1.status === 0;
+            const worksWithShell = test2.status === 0;
+            const worksWithCmd = test3.status === 0;
+            
+            console.log(`  Results - Without shell: ${worksWithoutShell}, With shell: ${worksWithShell}, With cmd: ${worksWithCmd}`);
+            
+            this.testResults.push({
+                name: 'Qoder Installation Shell Options',
+                passed: worksWithoutShell || worksWithShell || worksWithCmd,
+                details: `Without shell: ${worksWithoutShell}, With shell: ${worksWithShell}, With cmd: ${worksWithCmd}`
+            });
+            
+            return worksWithoutShell || worksWithShell || worksWithCmd;
+        } catch (error) {
+            console.log(`  ✗ Failed to test installation with shell options: ${error.message}`);
+            this.testResults.push({
+                name: 'Qoder Installation Shell Options',
+                passed: false,
+                details: `Failed to test: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 3: Test spawn vs spawnSync behavior
+    async testSpawnVsSpawnSync() {
+        console.log('\n[TEST 3] Testing spawn vs spawnSync behavior...');
+        
+        try {
+            const command = 'npm';
+            const args = ['--version'];
+            
+            // Test spawnSync
+            console.log('  Testing spawnSync...');
+            const syncResult = spawnSync(command, args, {
+                encoding: 'utf8',
+                timeout: 10000,
+                shell: true
+            });
+            
+            console.log(`  spawnSync - Status: ${syncResult.status}`);
+            
+            // Test spawn
+            console.log('  Testing spawn...');
+            const spawnResult = await new Promise((resolve) => {
+                const child = spawn(command, args, {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                    shell: true
+                });
+                
+                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({
+                        status: code,
+                        stdout: stdout,
+                        stderr: stderr
+                    });
+                });
+                
+                child.on('error', (error) => {
+                    resolve({
+                        status: null,
+                        error: error.message
+                    });
+                });
+                
+                // Timeout
+                setTimeout(() => {
+                    child.kill();
+                    resolve({
+                        status: null,
+                        error: 'Timeout'
+                    });
+                }, 11000);
+            });
+            
+            console.log(`  spawn - Status: ${spawnResult.status}`);
+            if (spawnResult.error) {
+                console.log(`  spawn - Error: ${spawnResult.error}`);
+            }
+            
+            const bothWork = syncResult.status === 0 && spawnResult.status === 0;
+            
+            this.testResults.push({
+                name: 'Spawn vs SpawnSync',
+                passed: bothWork,
+                details: `spawnSync: ${syncResult.status}, spawn: ${spawnResult.status}`
+            });
+            
+            return bothWork;
+        } catch (error) {
+            console.log(`  ✗ Failed to test spawn behavior: ${error.message}`);
+            this.testResults.push({
+                name: 'Spawn vs SpawnSync',
+                passed: false,
+                details: `Failed to test: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 4: Verify current installation implementation issues
+    async testCurrentInstallationImplementation() {
+        console.log('\n[TEST 4] Verifying current installation implementation...');
+        
+        try {
+            // Simulate the current implementation from main_english.js
+            const toolInfo = {
+                name: 'Qoder CLI',
+                install: 'npm install -g @qoder-ai/qodercli'
+            };
+            
+            console.log(`  Simulating current implementation for: ${toolInfo.name}`);
+            console.log(`  Install command: ${toolInfo.install}`);
+            
+            const installCmd = toolInfo.install.split(' ');
+            console.log(`  Command parts: ${JSON.stringify(installCmd)}`);
+            
+            // Current implementation (similar to lines 512-518 in main_english.js)
+            console.log('  Testing current implementation approach...');
+            const result = spawnSync(installCmd[0], installCmd.slice(1), {
+                encoding: 'utf8',
+                timeout: 300000, // 5 minutes
+                stdio: 'pipe', // Changed from 'inherit' to 'pipe' for testing
+                env: process.env
+            });
+            
+            console.log(`  Current implementation - Status: ${result.status}`);
+            if (result.error) {
+                console.log(`  Current implementation - Error: ${result.error.message}`);
+            }
+            if (result.stderr && result.stderr.length > 0) {
+                const stderrPreview = result.stderr.substring(0, 200);
+                console.log(`  Current implementation - Stderr preview: ${stderrPreview}${result.stderr.length > 200 ? '...' : ''}`);
+            }
+            
+            // Test with shell=true
+            console.log('  Testing current implementation with shell=true...');
+            const resultWithShell = spawnSync(installCmd[0], installCmd.slice(1), {
+                encoding: 'utf8',
+                timeout: 300000,
+                stdio: 'pipe',
+                env: process.env,
+                shell: true
+            });
+            
+            console.log(`  Current implementation with shell - Status: ${resultWithShell.status}`);
+            if (resultWithShell.error) {
+                console.log(`  Current implementation with shell - Error: ${resultWithShell.error.message}`);
+            }
+            if (resultWithShell.stderr && resultWithShell.stderr.length > 0) {
+                const stderrPreview = resultWithShell.stderr.substring(0, 200);
+                console.log(`  Current implementation with shell - Stderr preview: ${stderrPreview}${resultWithShell.stderr.length > 200 ? '...' : ''}`);
+            }
+            
+            this.testResults.push({
+                name: 'Current Installation Implementation',
+                passed: result.status === 0 || resultWithShell.status === 0,
+                details: `Without shell: ${result.status}, With shell: ${resultWithShell.status}`
+            });
+            
+            return result.status === 0 || resultWithShell.status === 0;
+        } catch (error) {
+            console.log(`  ✗ Failed to test current implementation: ${error.message}`);
+            this.testResults.push({
+                name: 'Current Installation Implementation',
+                passed: false,
+                details: `Failed to test: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Run all tests
+    async runAllTests() {
+        console.log('Improved CLI Installation Test');
+        console.log('='.repeat(40));
+        
+        await this.testNpmAvailability();
+        await this.testQoderInstallationWithShellOptions();
+        await this.testSpawnVsSpawnSync();
+        await this.testCurrentInstallationImplementation();
+        
+        // Summary
+        console.log('\n' + '='.repeat(40));
+        console.log('Improved Installation 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++;
+        });
+        
+        console.log(`\nOverall Result: ${passedTests}/${this.testResults.length} tests passed`);
+        
+        if (passedTests === this.testResults.length) {
+            console.log('✓ All improved installation tests passed!');
+        } else if (passedTests > 0) {
+            console.log('⚠ Some improved installation tests passed.');
+        } else {
+            console.log('✗ All improved installation tests failed.');
+        }
+        
+        return {
+            totalTests: this.testResults.length,
+            passedTests: passedTests,
+            results: this.testResults
+        };
+    }
+}
+
+// Run the tests
+async function runImprovedInstallTests() {
+    const tester = new ImprovedInstallTester();
+    const results = await tester.runAllTests();
+    return results;
+}
+
+// Export for use in other modules
+module.exports = { ImprovedInstallTester };
+
+// Run if called directly
+if (require.main === module) {
+    runImprovedInstallTests().then(results => {
+        process.exit(results.passedTests === results.totalTests ? 0 : 1);
+    }).catch(error => {
+        console.error('[Test Failed]:', error.message);
+        process.exit(1);
+    });
+}