stigmergy 1.0.89 → 1.0.93

package/test/final-deploy-test.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+/**
+ * Final Test for deployHooks Implementation
+ * This test verifies that the deployHooks function now properly executes installation scripts
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+class FinalDeployTester {
+    constructor() {
+        this.testResults = [];
+    }
+    
+    // Test 1: Verify deployHooks function can be imported and has the new functionality
+    async testDeployHooksFunctionality() {
+        console.log('[TEST 1] Verifying deployHooks function has new functionality...');
+        
+        try {
+            // Import the StigmergyInstaller class
+            const { StigmergyInstaller } = require('../src/main_english.js');
+            const installer = new StigmergyInstaller();
+            
+            // Check if deployHooks method exists
+            if (typeof installer.deployHooks !== 'function') {
+                console.log('  ✗ deployHooks method not found');
+                this.testResults.push({
+                    name: 'DeployHooks Functionality',
+                    passed: false,
+                    details: 'deployHooks method not found'
+                });
+                return false;
+            }
+            
+            // Check if the method includes the new configuration execution code
+            const methodCode = installer.deployHooks.toString();
+            const hasNewFunctionality = methodCode.includes('PostDeploymentConfigurer') && 
+                                       methodCode.includes('configureTool');
+            
+            if (hasNewFunctionality) {
+                console.log('  ✓ deployHooks includes new configuration execution functionality');
+            } else {
+                console.log('  ✗ deployHooks missing new configuration execution functionality');
+            }
+            
+            this.testResults.push({
+                name: 'DeployHooks Functionality',
+                passed: hasNewFunctionality,
+                details: hasNewFunctionality ? 
+                    'Includes PostDeploymentConfigurer and configureTool execution' :
+                    'Missing new configuration execution functionality'
+            });
+            
+            return hasNewFunctionality;
+        } catch (error) {
+            console.log(`  ✗ Failed to test deployHooks functionality: ${error.message}`);
+            this.testResults.push({
+                name: 'DeployHooks Functionality',
+                passed: false,
+                details: `Failed to test: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 2: Verify post-deployment config script integration
+    async testPostDeploymentConfigIntegration() {
+        console.log('\n[TEST 2] Verifying post-deployment config integration...');
+        
+        try {
+            // Check if the post-deployment config script can be imported
+            const { PostDeploymentConfigurer } = require('../scripts/post-deployment-config.js');
+            
+            // Check if the class exists
+            if (typeof PostDeploymentConfigurer === 'function') {
+                console.log('  ✓ PostDeploymentConfigurer class exists');
+                
+                // Try to instantiate it
+                const configurer = new PostDeploymentConfigurer();
+                
+                // Check if required methods exist
+                const hasRequiredMethods = typeof configurer.configureTool === 'function' &&
+                                          typeof configurer.checkInstallScript === 'function';
+                
+                if (hasRequiredMethods) {
+                    console.log('  ✓ PostDeploymentConfigurer has required methods');
+                } else {
+                    console.log('  ✗ PostDeploymentConfigurer missing required methods');
+                }
+                
+                this.testResults.push({
+                    name: 'Post-Deployment Config Integration',
+                    passed: hasRequiredMethods,
+                    details: hasRequiredMethods ? 
+                        'PostDeploymentConfigurer class and methods exist' :
+                        'Missing required methods in PostDeploymentConfigurer'
+                });
+                
+                return hasRequiredMethods;
+            } else {
+                console.log('  ✗ PostDeploymentConfigurer class not found');
+                this.testResults.push({
+                    name: 'Post-Deployment Config Integration',
+                    passed: false,
+                    details: 'PostDeploymentConfigurer class not found'
+                });
+                return false;
+            }
+        } catch (error) {
+            console.log(`  ✗ Failed to test post-deployment config integration: ${error.message}`);
+            this.testResults.push({
+                name: 'Post-Deployment Config Integration',
+                passed: false,
+                details: `Failed to test: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 3: Verify installation script execution would work
+    async testInstallationScriptExecutionFeasibility() {
+        console.log('\n[TEST 3] Verifying installation script execution feasibility...');
+        
+        try {
+            // Check if installation scripts exist in assets
+            const stigmergyAssetsDir = path.join(os.homedir(), '.stigmergy', 'assets', 'adapters');
+            
+            // Check a few key tools
+            const toolsToCheck = ['iflow', 'claude', 'qoder'];
+            let scriptsFound = 0;
+            
+            for (const tool of toolsToCheck) {
+                const installScriptPath = path.join(stigmergyAssetsDir, tool, `install_${tool}_integration.py`);
+                try {
+                    await fs.access(installScriptPath);
+                    console.log(`  ✓ ${tool} installation script found: ${installScriptPath}`);
+                    scriptsFound++;
+                } catch (error) {
+                    console.log(`  ✗ ${tool} installation script not found: ${installScriptPath}`);
+                }
+            }
+            
+            const allScriptsFound = scriptsFound === toolsToCheck.length;
+            
+            this.testResults.push({
+                name: 'Installation Script Execution Feasibility',
+                passed: allScriptsFound,
+                details: `Found ${scriptsFound}/${toolsToCheck.length} installation scripts`
+            });
+            
+            return allScriptsFound;
+        } catch (error) {
+            console.log(`  ✗ Failed to check installation script feasibility: ${error.message}`);
+            this.testResults.push({
+                name: 'Installation Script Execution Feasibility',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Run all tests
+    async runAllTests() {
+        console.log('Final Test for deployHooks Implementation');
+        console.log('='.repeat(50));
+        
+        await this.testDeployHooksFunctionality();
+        await this.testPostDeploymentConfigIntegration();
+        await this.testInstallationScriptExecutionFeasibility();
+        
+        // Summary
+        console.log('\n' + '='.repeat(50));
+        console.log('Final Implementation 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 tests passed! deployHooks implementation is complete.');
+        } else if (passedTests > 0) {
+            console.log('⚠ Some tests failed. deployHooks implementation may need adjustments.');
+        } else {
+            console.log('✗ All tests failed. deployHooks implementation is not complete.');
+        }
+        
+        return {
+            totalTests: this.testResults.length,
+            passedTests: passedTests,
+            results: this.testResults
+        };
+    }
+}
+
+// Run the tests
+async function runFinalDeployTests() {
+    const tester = new FinalDeployTester();
+    const results = await tester.runAllTests();
+    return results;
+}
+
+// Export for use in other modules
+module.exports = { FinalDeployTester };
+
+// Run if called directly
+if (require.main === module) {
+    runFinalDeployTests().then(results => {
+        process.exit(results.passedTests === results.totalTests ? 0 : 1);
+    }).catch(error => {
+        console.error('[Test Failed]:', error.message);
+        process.exit(1);
+    });
+}

package/test/final-install-test.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+/**
+ * Final Test for Improved Installation Implementation
+ * This test verifies that the improved installation implementation works correctly
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+class FinalInstallTest {
+    constructor() {
+        this.testResults = [];
+    }
+    
+    // Test 1: Verify the improved installation code was implemented correctly
+    async testImprovedInstallationCode() {
+        console.log('[TEST 1] Verifying improved installation code implementation...');
+        
+        try {
+            // Read the main_english.js file
+            const mainFilePath = path.join(__dirname, '..', 'src', 'main_english.js');
+            const mainContent = await fs.readFile(mainFilePath, 'utf8');
+            
+            // Check for key improvements
+            const hasShellTrue = mainContent.includes('shell: true');
+            const hasFallbackLogic = mainContent.includes('if (result.status !== 0 && result.status !== null)');
+            const hasDebugLogging = mainContent.includes('[DEBUG] Installing');
+            const hasErrorDetails = mainContent.includes('Installation error:');
+            
+            console.log(`  shell: true option: ${hasShellTrue}`);
+            console.log(`  Fallback logic: ${hasFallbackLogic}`);
+            console.log(`  Debug logging: ${hasDebugLogging}`);
+            console.log(`  Error details: ${hasErrorDetails}`);
+            
+            const allImprovementsImplemented = hasShellTrue && hasFallbackLogic && hasDebugLogging && hasErrorDetails;
+            
+            this.testResults.push({
+                name: 'Improved Installation Code',
+                passed: allImprovementsImplemented,
+                details: `shell:true=${hasShellTrue}, fallback=${hasFallbackLogic}, debug=${hasDebugLogging}, error_details=${hasErrorDetails}`
+            });
+            
+            return allImprovementsImplemented;
+        } catch (error) {
+            console.log(`  ✗ Failed to check improved installation code: ${error.message}`);
+            this.testResults.push({
+                name: 'Improved Installation Code',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 2: Verify installation command format is correct
+    async testInstallationCommandFormat() {
+        console.log('\n[TEST 2] Verifying installation command format...');
+        
+        try {
+            // Read the main_english.js file
+            const mainFilePath = path.join(__dirname, '..', 'src', 'main_english.js');
+            const mainContent = await fs.readFile(mainFilePath, 'utf8');
+            
+            // Check for Qoder CLI installation command
+            const hasQoderInstall = mainContent.includes('@qoder-ai/qodercli');
+            const hasNpmInstallFormat = mainContent.includes('npm install -g');
+            
+            console.log(`  Qoder CLI package reference: ${hasQoderInstall}`);
+            console.log(`  npm install format: ${hasNpmInstallFormat}`);
+            
+            const correctFormat = hasQoderInstall && hasNpmInstallFormat;
+            
+            this.testResults.push({
+                name: 'Installation Command Format',
+                passed: correctFormat,
+                details: `Qoder package=${hasQoderInstall}, npm install format=${hasNpmInstallFormat}`
+            });
+            
+            return correctFormat;
+        } catch (error) {
+            console.log(`  ✗ Failed to check installation command format: ${error.message}`);
+            this.testResults.push({
+                name: 'Installation Command Format',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 3: Verify error handling improvements
+    async testErrorHandlingImprovements() {
+        console.log('\n[TEST 3] Verifying error handling improvements...');
+        
+        try {
+            // Read the main_english.js file
+            const mainFilePath = path.join(__dirname, '..', 'src', 'main_english.js');
+            const mainContent = await fs.readFile(mainFilePath, 'utf8');
+            
+            // Check for improved error handling
+            const hasTryCatch = mainContent.includes('try {') && mainContent.includes('catch');
+            const hasSpecificErrorMessages = mainContent.includes('Failed to install') && mainContent.includes('Please run manually');
+            const hasExitCodeReporting = mainContent.includes('exit code');
+            
+            console.log(`  Try-catch blocks: ${hasTryCatch}`);
+            console.log(`  Specific error messages: ${hasSpecificErrorMessages}`);
+            console.log(`  Exit code reporting: ${hasExitCodeReporting}`);
+            
+            const goodErrorHandling = hasTryCatch && hasSpecificErrorMessages && hasExitCodeReporting;
+            
+            this.testResults.push({
+                name: 'Error Handling Improvements',
+                passed: goodErrorHandling,
+                details: `try-catch=${hasTryCatch}, specific_errors=${hasSpecificErrorMessages}, exit_code=${hasExitCodeReporting}`
+            });
+            
+            return goodErrorHandling;
+        } catch (error) {
+            console.log(`  ✗ Failed to check error handling improvements: ${error.message}`);
+            this.testResults.push({
+                name: 'Error Handling Improvements',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Test 4: Verify timeout and environment settings
+    async testTimeoutAndEnvironment() {
+        console.log('\n[TEST 4] Verifying timeout and environment settings...');
+        
+        try {
+            // Read the main_english.js file
+            const mainFilePath = path.join(__dirname, '..', 'src', 'main_english.js');
+            const mainContent = await fs.readFile(mainFilePath, 'utf8');
+            
+            // Check for timeout and environment settings
+            const hasTimeout = mainContent.includes('timeout: 300000');
+            const hasEnvironment = mainContent.includes('env: process.env');
+            const hasStdioSetting = mainContent.includes('stdio:');
+            
+            console.log(`  5-minute timeout: ${hasTimeout}`);
+            console.log(`  Environment passing: ${hasEnvironment}`);
+            console.log(`  Stdio setting: ${hasStdioSetting}`);
+            
+            const correctSettings = hasTimeout && hasEnvironment && hasStdioSetting;
+            
+            this.testResults.push({
+                name: 'Timeout and Environment Settings',
+                passed: correctSettings,
+                details: `timeout=${hasTimeout}, environment=${hasEnvironment}, stdio=${hasStdioSetting}`
+            });
+            
+            return correctSettings;
+        } catch (error) {
+            console.log(`  ✗ Failed to check timeout and environment settings: ${error.message}`);
+            this.testResults.push({
+                name: 'Timeout and Environment Settings',
+                passed: false,
+                details: `Failed to check: ${error.message}`
+            });
+            return false;
+        }
+    }
+    
+    // Run all tests
+    async runAllTests() {
+        console.log('Final Test for Improved Installation Implementation');
+        console.log('='.repeat(50));
+        
+        await this.testImprovedInstallationCode();
+        await this.testInstallationCommandFormat();
+        await this.testErrorHandlingImprovements();
+        await this.testTimeoutAndEnvironment();
+        
+        // Summary
+        console.log('\n' + '='.repeat(50));
+        console.log('Final Installation Implementation 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 final implementation tests passed!');
+            console.log('✓ Installation implementation has been successfully improved!');
+        } else if (passedTests > 0) {
+            console.log('⚠ Some final implementation tests passed.');
+        } else {
+            console.log('✗ All final implementation tests failed.');
+        }
+        
+        return {
+            totalTests: this.testResults.length,
+            passedTests: passedTests,
+            results: this.testResults
+        };
+    }
+}
+
+// Run the tests
+async function runFinalInstallTests() {
+    const tester = new FinalInstallTest();
+    const results = await tester.runAllTests();
+    return results;
+}
+
+// Export for use in other modules
+module.exports = { FinalInstallTest };
+
+// Run if called directly
+if (require.main === module) {
+    runFinalInstallTests().then(results => {
+        process.exit(results.passedTests === results.totalTests ? 0 : 1);
+    }).catch(error => {
+        console.error('[Test Failed]:', error.message);
+        process.exit(1);
+    });
+}