stigmergy 1.0.89 → 1.0.92

package/test/postinstall-test.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+/**
+ * Test for postinstall behavior and error handling
+ * This test verifies that the npm postinstall script works correctly
+ * and provides graceful degradation when problems occur
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+class PostInstallTester {
+    constructor() {
+        this.testResults = [];
+    }
+    
+    // Test 1: Verify postinstall script exists and is correct
+    async testPostInstallScript() {
+        console.log('[TEST 1] Verifying postinstall script configuration...');
+        
+        try {
+            // Read package.json
+            const packageJsonPath = path.join(__dirname, '..', 'package.json');
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+            
+            // Check if postinstall script exists
+            if (!packageJson.scripts || !packageJson.scripts.postinstall) {
+                console.log('  ✗ postinstall script not found in package.json');
+                this.testResults.push({
+                    name: 'Postinstall Script Configuration',
+                    passed: false,
+                    details: 'postinstall script not found in package.json'
+                });
+                return false;
+            }
+            
+            const postinstallScript = packageJson.scripts.postinstall;
+            console.log(`  Postinstall script: ${postinstallScript}`);
+            
+            // Check if it calls the auto-install command
+            const hasAutoInstall = postinstallScript.includes('auto-install');
+            const hasMainScript = postinstallScript.includes('src/main_english.js');
+            
+            if (hasAutoInstall && hasMainScript) {
+                console.log('  ✓ postinstall script correctly configured for auto-install');
+            } else {
+                console.log('  ✗ postinstall script missing auto-install configuration');
+            }
+            
+            this.testResults.push({
+                name: 'Postinstall Script Configuration',
+                passed: hasAutoInstall && hasMainScript,
+                details: hasAutoInstall && hasMainScript ? 
+                    'Correctly configured for auto-install' : 
+                    'Missing auto-install configuration'
+            });
+            
+            return hasAutoInstall && hasMainScript;
+        } catch (error) {
+            console.log(`  ✗ Failed to check postinstall script: ${error.message}`);
+            this.testResults.push({
+                name: 'Postinstall Script Configuration',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 2: Verify auto-install command exists
+    async testAutoInstallCommand() {
+        console.log('\n[TEST 2] Verifying auto-install command implementation...');
+        
+        try {
+            // Read main script
+            const mainScriptPath = path.join(__dirname, '..', 'src', 'main_english.js');
+            const mainScript = await fs.readFile(mainScriptPath, 'utf8');
+            
+            // Check if auto-install case exists
+            const hasAutoInstallCase = mainScript.includes('case \'auto-install\':') || 
+                                    mainScript.includes('case "auto-install":');
+            
+            if (hasAutoInstallCase) {
+                console.log('  ✓ auto-install command implemented');
+            } else {
+                console.log('  ✗ auto-install command not implemented');
+            }
+            
+            // Check if it includes error handling
+            const hasErrorHandling = mainScript.includes('try {') && mainScript.includes('catch');
+            
+            this.testResults.push({
+                name: 'Auto-Install Command Implementation',
+                passed: hasAutoInstallCase,
+                details: hasAutoInstallCase ? 
+                    'auto-install command implemented' : 
+                    'auto-install command not implemented'
+            });
+            
+            return hasAutoInstallCase;
+        } catch (error) {
+            console.log(`  ✗ Failed to check auto-install command: ${error.message}`);
+            this.testResults.push({
+                name: 'Auto-Install Command Implementation',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 3: Verify graceful degradation and user guidance
+    async testGracefulDegradation() {
+        console.log('\n[TEST 3] Verifying graceful degradation and user guidance...');
+        
+        try {
+            // Read main script
+            const mainScriptPath = path.join(__dirname, '..', 'src', 'main_english.js');
+            const mainScript = await fs.readFile(mainScriptPath, 'utf8');
+            
+            // Check if auto-install includes user guidance
+            const hasUserGuidance = mainScript.includes('For full functionality') ||
+                                  mainScript.includes('please run') ||
+                                  mainScript.includes('stigmergy install') ||
+                                  mainScript.includes('stigmergy setup');
+            
+            if (hasUserGuidance) {
+                console.log('  ✓ User guidance messages found in auto-install');
+            } else {
+                console.log('  ✗ User guidance messages not found in auto-install');
+            }
+            
+            // Check if it handles missing tools gracefully
+            const hasMissingToolsHandling = mainScript.includes('Skipping automatic installation') ||
+                                          mainScript.includes('missing AI CLI tools') ||
+                                          mainScript.includes('autoMissing');
+            
+            if (hasMissingToolsHandling) {
+                console.log('  ✓ Missing tools handling found in auto-install');
+            } else {
+                console.log('  ✗ Missing tools handling not found in auto-install');
+            }
+            
+            // Check if it shows success message
+            const hasSuccessMessage = mainScript.includes('SUCCESS') && 
+                                    mainScript.includes('installed successfully');
+            
+            this.testResults.push({
+                name: 'Graceful Degradation and Guidance',
+                passed: hasUserGuidance && hasMissingToolsHandling && hasSuccessMessage,
+                details: `User guidance: ${hasUserGuidance}, Missing tools handling: ${hasMissingToolsHandling}, Success message: ${hasSuccessMessage}`
+            });
+            
+            return hasUserGuidance && hasMissingToolsHandling && hasSuccessMessage;
+        } catch (error) {
+            console.log(`  ✗ Failed to check graceful degradation: ${error.message}`);
+            this.testResults.push({
+                name: 'Graceful Degradation and Guidance',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 4: Verify error handling in auto-install
+    async testErrorHandling() {
+        console.log('\n[TEST 4] Verifying error handling in auto-install...');
+        
+        try {
+            // Read main script
+            const mainScriptPath = path.join(__dirname, '..', 'src', 'main_english.js');
+            const mainScript = await fs.readFile(mainScriptPath, 'utf8');
+            
+            // Check if main function has error handling
+            const hasMainErrorHandling = mainScript.includes('main().catch') ||
+                                       mainScript.includes('try {') && mainScript.includes('catch');
+            
+            if (hasMainErrorHandling) {
+                console.log('  ✓ Main function has error handling');
+            } else {
+                console.log('  ✗ Main function missing error handling');
+            }
+            
+            // Check if auto-install has specific error handling
+            const autoInstallSection = mainScript.split('case \'auto-install\':')[1] || 
+                                     mainScript.split('case "auto-install":')[1] || '';
+            
+            const hasAutoInstallErrorHandling = autoInstallSection.includes('try {') && 
+                                              autoInstallSection.includes('catch');
+            
+            this.testResults.push({
+                name: 'Error Handling',
+                passed: hasMainErrorHandling,
+                details: `Main error handling: ${hasMainErrorHandling}, Auto-install error handling: ${hasAutoInstallErrorHandling}`
+            });
+            
+            return hasMainErrorHandling;
+        } catch (error) {
+            console.log(`  ✗ Failed to check error handling: ${error.message}`);
+            this.testResults.push({
+                name: 'Error Handling',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Run all tests
+    async runAllTests() {
+        console.log('Postinstall Behavior and Error Handling Test');
+        console.log('='.repeat(50));
+        
+        await this.testPostInstallScript();
+        await this.testAutoInstallCommand();
+        await this.testGracefulDegradation();
+        await this.testErrorHandling();
+        
+        // Summary
+        console.log('\n' + '='.repeat(50));
+        console.log('Postinstall Test Summary:');
+        console.log('='.repeat(50));
+        
+        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 postinstall tests passed! Package should work correctly.');
+        } else if (passedTests > 0) {
+            console.log('⚠ Some postinstall tests failed. Package may need improvements.');
+        } else {
+            console.log('✗ All postinstall tests failed. Package needs significant improvements.');
+        }
+        
+        return {
+            totalTests: this.testResults.length,
+            passedTests: passedTests,
+            results: this.testResults
+        };
+    }
+}
+
+// Run the tests
+async function runPostInstallTests() {
+    const tester = new PostInstallTester();
+    const results = await tester.runAllTests();
+    return results;
+}
+
+// Export for use in other modules
+module.exports = { PostInstallTester };
+
+// Run if called directly
+if (require.main === module) {
+    runPostInstallTests().then(results => {
+        process.exit(results.passedTests === results.totalTests ? 0 : 1);
+    }).catch(error => {
+        console.error('[Test Failed]:', error.message);
+        process.exit(1);
+    });
+}

package/test/simple-iflow-hook-test.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+/**
+ * Simple iFlow Hook Detection Test
+ * This script tests if iFlow can detect the Stigmergy hook configuration
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+async function testIFlowHookDetection() {
+    console.log('Simple iFlow Hook Detection Test');
+    console.log('='.repeat(40));
+    
+    // Check if the hook configuration file exists and is properly formatted
+    const hookConfigPath = path.join(os.homedir(), '.config', 'iflow', 'hooks.yml');
+    
+    try {
+        await fs.access(hookConfigPath);
+        console.log('✓ Hook configuration file exists');
+        
+        const configContent = await fs.readFile(hookConfigPath, 'utf8');
+        console.log('✓ Configuration file is readable');
+        
+        // Check if it contains the expected Stigmergy configuration
+        if (configContent.includes('CrossCLIHookAdapter')) {
+            console.log('✓ Stigmergy CrossCLIHookAdapter found in configuration');
+        } else {
+            console.log('✗ Stigmergy CrossCLIHookAdapter not found in configuration');
+        }
+        
+        if (configContent.includes('cross_cli_enabled: true')) {
+            console.log('✓ Cross-CLI functionality is enabled');
+        } else {
+            console.log('✗ Cross-CLI functionality is not enabled');
+        }
+        
+        // Parse the YAML to verify structure
+        try {
+            const yaml = await import('js-yaml');
+            const parsedConfig = yaml.load(configContent);
+            
+            if (parsedConfig && parsedConfig.plugins && Array.isArray(parsedConfig.plugins)) {
+                console.log('✓ Configuration has valid plugin structure');
+                
+                const stigmergyPlugin = parsedConfig.plugins.find(plugin => 
+                    plugin.name === 'CrossCLIHookAdapter'
+                );
+                
+                if (stigmergyPlugin) {
+                    console.log('✓ Stigmergy plugin found in parsed configuration');
+                    console.log('  Plugin details:');
+                    console.log(`    Name: ${stigmergyPlugin.name}`);
+                    console.log(`    Module: ${stigmergyPlugin.module}`);
+                    console.log(`    Enabled: ${stigmergyPlugin.enabled}`);
+                    console.log(`    Supported CLIs: ${stigmergyPlugin.config?.supported_clis?.join(', ') || 'None'}`);
+                } else {
+                    console.log('✗ Stigmergy plugin not found in parsed configuration');
+                }
+            } else {
+                console.log('✗ Configuration does not have valid plugin structure');
+            }
+        } catch (parseError) {
+            console.log('⚠ Could not parse YAML configuration:', parseError.message);
+        }
+        
+    } catch (error) {
+        console.log('✗ Hook configuration file not found or not accessible');
+        console.log('  Path:', hookConfigPath);
+        console.log('  Error:', error.message);
+        return false;
+    }
+    
+    // Test if iFlow can load the configuration by running a simple command
+    console.log('\n[Test] Running iFlow with debug mode to check hook loading...');
+    
+    return new Promise((resolve) => {
+        const child = spawn('iflow', ['--debug', '--prompt', 'echo "test"'], {
+            stdio: 'pipe',
+            timeout: 15000
+        });
+        
+        let output = '';
+        let errorOutput = '';
+        
+        child.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        
+        child.stderr.on('data', (data) => {
+            errorOutput += data.toString();
+        });
+        
+        child.on('close', (code) => {
+            const fullOutput = output + errorOutput;
+            
+            console.log(`Exit code: ${code}`);
+            
+            // Look for hook-related messages in the output
+            if (fullOutput.includes('hook') || fullOutput.includes('Hook') || fullOutput.includes('plugin')) {
+                console.log('✓ Hook/plugin related messages found in iFlow output');
+                
+                // Look specifically for Stigmergy-related messages
+                if (fullOutput.includes('stigmergy') || fullOutput.includes('Stigmergy') || 
+                    fullOutput.includes('CrossCLI') || fullOutput.includes('cross')) {
+                    console.log('✓ Stigmergy-related messages found in iFlow output');
+                } else {
+                    console.log('ℹ Stigmergy-specific messages not found, but hooks are mentioned');
+                }
+            } else {
+                console.log('ℹ No hook/plugin messages found in iFlow output');
+            }
+            
+            // Show a preview of the output
+            const preview = fullOutput.substring(0, 500);
+            console.log('\nOutput preview:');
+            console.log(preview + (fullOutput.length > 500 ? '...' : ''));
+            
+            resolve(true);
+        });
+        
+        child.on('error', (error) => {
+            console.log('✗ Failed to run iFlow:', error.message);
+            resolve(false);
+        });
+    });
+}
+
+// Run the test
+testIFlowHookDetection().then(() => {
+    console.log('\n' + '='.repeat(40));
+    console.log('Test completed');
+}).catch(error => {
+    console.error('Test failed:', error.message);
+});