stigmergy 1.2.0 → 1.2.6

package/test/plugin-deployment-test.js

@@ -1,316 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Stigmergy Plugin Deployment Test
- * This script tests the plugin deployment mechanism for all supported CLI tools
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const os = require('os');
-const { spawn } = require('child_process');
-
-// CLI Tools Configuration (same as in main_english.js)
-const CLI_TOOLS = {
-    claude: {
-        name: 'Claude CLI',
-        version: 'claude --version',
-        install: 'npm install -g @anthropic-ai/claude-cli',
-        hooksDir: path.join(os.homedir(), '.claude', 'hooks'),
-        config: path.join(os.homedir(), '.claude', 'config.json')
-    },
-    gemini: {
-        name: 'Gemini CLI',
-        version: 'gemini --version',
-        install: 'npm install -g @google/generative-ai-cli',
-        hooksDir: path.join(os.homedir(), '.gemini', 'extensions'),
-        config: path.join(os.homedir(), '.gemini', 'config.json')
-    },
-    qwen: {
-        name: 'Qwen CLI',
-        version: 'qwen --version',
-        install: 'npm install -g @qwen-code/qwen-code',
-        hooksDir: path.join(os.homedir(), '.qwen', 'hooks'),
-        config: path.join(os.homedir(), '.qwen', 'config.json')
-    },
-    iflow: {
-        name: 'iFlow CLI',
-        version: 'iflow --version',
-        install: 'npm install -g iflow-cli',
-        hooksDir: path.join(os.homedir(), '.iflow', 'hooks'),
-        config: path.join(os.homedir(), '.iflow', 'config.json')
-    },
-    qodercli: {
-        name: 'Qoder CLI',
-        version: 'qodercli --version',
-        install: 'npm install -g @qoder-ai/qodercli',
-        hooksDir: path.join(os.homedir(), '.qoder', 'hooks'),
-        config: path.join(os.homedir(), '.qoder', 'config.json')
-    },
-    codebuddy: {
-        name: 'CodeBuddy CLI',
-        version: 'codebuddy --version',
-        install: 'npm install -g codebuddy-cli',
-        hooksDir: path.join(os.homedir(), '.codebuddy', 'hooks'),
-        config: path.join(os.homedir(), '.codebuddy', 'config.json')
-    },
-    copilot: {
-        name: 'GitHub Copilot CLI',
-        version: 'copilot --version',
-        install: 'npm install -g @github/copilot-cli',
-        hooksDir: path.join(os.homedir(), '.copilot', 'mcp'),
-        config: path.join(os.homedir(), '.copilot', 'config.json')
-    },
-    codex: {
-        name: 'OpenAI Codex CLI',
-        version: 'codex --version',
-        install: 'npm install -g openai-codex-cli',
-        hooksDir: path.join(os.homedir(), '.config', 'codex', 'slash_commands'),
-        config: path.join(os.homedir(), '.codex', 'config.json')
-    }
-};
-
-class PluginDeploymentTester {
-    constructor() {
-        this.results = {};
-    }
-    
-    // Check if a CLI tool is installed
-    async isToolInstalled(toolName) {
-        const tool = CLI_TOOLS[toolName];
-        if (!tool) return false;
-        
-        // Extract the actual command from the version string
-        const command = tool.version.split(' ')[0];
-        
-        return new Promise((resolve) => {
-            const child = spawn(command, ['--version'], {
-                stdio: 'pipe',
-                timeout: 5000
-            });
-            
-            let output = '';
-            let error = '';
-            
-            child.stdout.on('data', (data) => {
-                output += data.toString();
-            });
-            
-            child.stderr.on('data', (data) => {
-                error += data.toString();
-            });
-            
-            child.on('close', (code) => {
-                resolve(code === 0 && (output.length > 0 || error.length > 0));
-            });
-            
-            child.on('error', () => {
-                resolve(false);
-            });
-        });
-    }
-    
-    // Check if hooks directory exists and has files
-    async checkHooksDirectory(toolName) {
-        const tool = CLI_TOOLS[toolName];
-        if (!tool) return { exists: false, files: [] };
-        
-        try {
-            await fs.access(tool.hooksDir);
-            const files = await fs.readdir(tool.hooksDir);
-            return { 
-                exists: true, 
-                files: files,
-                path: tool.hooksDir
-            };
-        } catch (error) {
-            return { exists: false, files: [], path: tool.hooksDir };
-        }
-    }
-    
-    // Check if Stigmergy assets exist
-    async checkStigmergyAssets(toolName) {
-        const assetsPath = path.join(os.homedir(), '.stigmergy', 'assets', 'adapters', toolName);
-        try {
-            await fs.access(assetsPath);
-            const files = await fs.readdir(assetsPath);
-            return { exists: true, files: files, path: assetsPath };
-        } catch (error) {
-            return { exists: false, files: [], path: assetsPath };
-        }
-    }
-    
-    // Test deployment for a specific tool
-    async testToolDeployment(toolName) {
-        console.log(`\n[Test] Testing ${toolName} deployment...`);
-        
-        const result = {
-            toolName,
-            installed: false,
-            hooksDir: { exists: false, files: [] },
-            assets: { exists: false, files: [] },
-            deploymentStatus: 'unknown'
-        };
-        
-        // Check if tool is installed
-        result.installed = await this.isToolInstalled(toolName);
-        console.log(`  Installed: ${result.installed ? '✓' : '✗'}`);
-        
-        // Check hooks directory
-        result.hooksDir = await this.checkHooksDirectory(toolName);
-        console.log(`  Hooks Dir: ${result.hooksDir.exists ? '✓' : '✗'} (${result.hooksDir.files.length} files)`);
-        if (result.hooksDir.exists) {
-            console.log(`    Path: ${result.hooksDir.path}`);
-            result.hooksDir.files.forEach(file => console.log(`    - ${file}`));
-        }
-        
-        // Check Stigmergy assets
-        result.assets = await this.checkStigmergyAssets(toolName);
-        console.log(`  Assets: ${result.assets.exists ? '✓' : '✗'} (${result.assets.files.length} files)`);
-        if (result.assets.exists) {
-            console.log(`    Path: ${result.assets.path}`);
-            result.assets.files.forEach(file => console.log(`    - ${file}`));
-        }
-        
-        // Determine deployment status
-        if (result.installed && result.hooksDir.exists && result.hooksDir.files.length > 0) {
-            result.deploymentStatus = 'successful';
-        } else if (result.installed && result.hooksDir.exists) {
-            result.deploymentStatus = 'partial'; // Directory exists but no files
-        } else if (result.installed) {
-            result.deploymentStatus = 'missing_hooks'; // Installed but no hooks
-        } else {
-            result.deploymentStatus = 'not_installed';
-        }
-        
-        console.log(`  Status: ${result.deploymentStatus}`);
-        
-        return result;
-    }
-    
-    // Test all tools
-    async testAllTools() {
-        console.log('Stigmergy Plugin Deployment Test');
-        console.log('='.repeat(40));
-        
-        const toolNames = Object.keys(CLI_TOOLS);
-        const results = [];
-        
-        for (const toolName of toolNames) {
-            const result = await this.testToolDeployment(toolName);
-            results.push(result);
-        }
-        
-        // Summary
-        console.log('\n' + '='.repeat(40));
-        console.log('Deployment Summary:');
-        console.log('='.repeat(40));
-        
-        const statusCounts = {
-            successful: 0,
-            partial: 0,
-            missing_hooks: 0,
-            not_installed: 0
-        };
-        
-        results.forEach(result => {
-            statusCounts[result.deploymentStatus]++;
-            console.log(`${result.toolName}: ${result.deploymentStatus}`);
-        });
-        
-        console.log('\nStatus Counts:');
-        Object.entries(statusCounts).forEach(([status, count]) => {
-            console.log(`  ${status}: ${count}`);
-        });
-        
-        // Identify issues
-        const issues = results.filter(r => r.deploymentStatus !== 'successful');
-        if (issues.length > 0) {
-            console.log('\nIssues Found:');
-            issues.forEach(issue => {
-                console.log(`  ${issue.toolName}: ${issue.deploymentStatus}`);
-                if (issue.deploymentStatus === 'partial') {
-                    console.log(`    Hooks directory exists but is empty`);
-                } else if (issue.deploymentStatus === 'missing_hooks') {
-                    console.log(`    Tool installed but hooks not deployed`);
-                } else if (issue.deploymentStatus === 'not_installed') {
-                    console.log(`    Tool not installed`);
-                }
-            });
-        }
-        
-        return results;
-    }
-    
-    // Test iFlow specifically
-    async testIFlowIntegration() {
-        console.log('\n[iFlow Integration Test]');
-        console.log('-'.repeat(20));
-        
-        // Check if iFlow config can detect hooks
-        const iflowConfigPath = path.join(os.homedir(), '.iflow', 'config.yml');
-        try {
-            await fs.access(iflowConfigPath);
-            const configContent = await fs.readFile(iflowConfigPath, 'utf8');
-            console.log('iFlow config file found');
-            
-            if (configContent.includes('hooks') || configContent.includes('plugins')) {
-                console.log('✓ Hooks/plugins section found in iFlow config');
-            } else {
-                console.log('✗ No hooks/plugins section found in iFlow config');
-            }
-        } catch (error) {
-            console.log('iFlow config file not found or not readable');
-        }
-        
-        // Try to run iFlow with hook detection
-        try {
-            const child = spawn('iflow', ['hooks'], {
-                stdio: 'pipe',
-                timeout: 10000
-            });
-            
-            let output = '';
-            child.stdout.on('data', (data) => {
-                output += data.toString();
-            });
-            
-            await new Promise((resolve) => {
-                child.on('close', resolve);
-                child.on('error', resolve);
-            });
-            
-            if (output.includes('stigmergy') || output.includes('Stigmergy')) {
-                console.log('✓ iFlow can detect Stigmergy hooks');
-            } else {
-                console.log('✗ iFlow cannot detect Stigmergy hooks');
-                console.log('Output:', output.substring(0, 200) + '...');
-            }
-        } catch (error) {
-            console.log('Could not test iFlow hook detection:', error.message);
-        }
-    }
-}
-
-// Run the tests
-async function runDeploymentTests() {
-    const tester = new PluginDeploymentTester();
-    const results = await tester.testAllTools();
-    await tester.testIFlowIntegration();
-    
-    return results;
-}
-
-// Export for use in other modules
-module.exports = { PluginDeploymentTester };
-
-// Run if called directly
-if (require.main === module) {
-    runDeploymentTests().then(results => {
-        console.log('\n[Test Complete]');
-        process.exit(0);
-    }).catch(error => {
-        console.error('[Test Failed]:', error.message);
-        process.exit(1);
-    });
-}

package/test/postinstall-test.js

@@ -1,269 +0,0 @@
-#!/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);
-    });
-}