stigmergy 1.2.13 → 1.3.2-beta.1

package/scripts/test-runner.js

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+
+/**
+ * Enhanced Test Runner for HookDeploymentManager Test Suite
+ * Provides comprehensive testing with reporting and analysis
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+class TestRunner {
+  constructor() {
+    this.testResults = {
+      unit: { passed: 0, failed: 0, total: 0, duration: 0 },
+      integration: { passed: 0, failed: 0, total: 0, duration: 0 },
+      regression: { passed: 0, failed: 0, total: 0, duration: 0 },
+      performance: { passed: 0, failed: 0, total: 0, duration: 0 }
+    };
+    this.startTime = Date.now();
+  }
+
+  log(message, type = 'info') {
+    const colors = {
+      info: chalk.blue,
+      success: chalk.green,
+      warning: chalk.yellow,
+      error: chalk.red
+    };
+
+    console.log(colors[type](`[${new Date().toLocaleTimeString()}] ${message}`));
+  }
+
+  async runCommand(command, description) {
+    this.log(`Running: ${description}...`);
+    const startTime = Date.now();
+
+    try {
+      const output = execSync(command, {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      });
+
+      const duration = Date.now() - startTime;
+      this.log(`${description} completed successfully (${duration}ms)`, 'success');
+
+      return {
+        success: true,
+        output,
+        duration
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.log(`${description} failed after ${duration}ms`, 'error');
+
+      return {
+        success: false,
+        error: error.message,
+        output: error.stdout,
+        duration
+      };
+    }
+  }
+
+  parseJestOutput(output) {
+    const lines = output.split('\n');
+    const results = {
+      passed: 0,
+      failed: 0,
+      total: 0,
+      suites: 0
+    };
+
+    lines.forEach(line => {
+      const match = line.match(/Tests:\s+(\d+)\s+passed,\s+(\d+)\s+failed/);
+      if (match) {
+        results.passed = parseInt(match[1]);
+        results.failed = parseInt(match[2]);
+        results.total = results.passed + results.failed;
+      }
+
+      const suiteMatch = line.match(/Test Suites:\s+(\d+)\s+passed,\s+(\d+)\s+failed/);
+      if (suiteMatch) {
+        results.suites = parseInt(suiteMatch[1]) + parseInt(suiteMatch[2]);
+      }
+    });
+
+    return results;
+  }
+
+  async runUnitTests() {
+    this.log('\n🧪 Running Unit Tests', 'info');
+
+    const result = await this.runCommand(
+      'npm run test:unit -- --verbose --json',
+      'Unit Tests'
+    );
+
+    if (result.success) {
+      const jestOutput = result.output;
+      try {
+        const jsonMatch = jestOutput.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          const jestResults = JSON.parse(jsonMatch[0]);
+          this.testResults.unit.passed = jestResults.numPassedTests || 0;
+          this.testResults.unit.failed = jestResults.numFailedTests || 0;
+          this.testResults.unit.total = jestResults.numTotalTests || 0;
+          this.testResults.unit.duration = jestResults.testResults?.reduce(
+            (total, test) => total + (test.duration || 0), 0
+          ) || 0;
+        } else {
+          const parsed = this.parseJestOutput(result.output);
+          Object.assign(this.testResults.unit, parsed);
+        }
+      } catch (parseError) {
+        this.log('Failed to parse Jest output, using fallback parsing', 'warning');
+        const parsed = this.parseJestOutput(result.output);
+        Object.assign(this.testResults.unit, parsed);
+      }
+    } else {
+      this.testResults.unit.failed = 1;
+    }
+
+    return result.success;
+  }
+
+  async runIntegrationTests() {
+    this.log('\n🔗 Running Integration Tests', 'info');
+
+    const result = await this.runCommand(
+      'npm run test:integration -- --verbose',
+      'Integration Tests'
+    );
+
+    if (result.success) {
+      const parsed = this.parseJestOutput(result.output);
+      Object.assign(this.testResults.integration, parsed);
+      this.testResults.integration.duration = result.duration;
+    } else {
+      this.testResults.integration.failed = 1;
+    }
+
+    return result.success;
+  }
+
+  async runRegressionTests() {
+    this.log('\n🔄 Running Regression Tests', 'info');
+
+    const result = await this.runCommand(
+      'npm run test:regression -- --verbose',
+      'Regression Tests'
+    );
+
+    if (result.success) {
+      const parsed = this.parseJestOutput(result.output);
+      Object.assign(this.testResults.regression, parsed);
+      this.testResults.regression.duration = result.duration;
+    } else {
+      this.testResults.regression.failed = 1;
+    }
+
+    return result.success;
+  }
+
+  async runPerformanceTests() {
+    this.log('\n⚡ Running Performance Tests', 'info');
+
+    const result = await this.runCommand(
+      'npm run test:performance -- --verbose',
+      'Performance Tests'
+    );
+
+    if (result.success) {
+      const parsed = this.parseJestOutput(result.output);
+      Object.assign(this.testResults.performance, parsed);
+      this.testResults.performance.duration = result.duration;
+    } else {
+      this.testResults.performance.failed = 1;
+    }
+
+    return result.success;
+  }
+
+  generateReport() {
+    const totalDuration = Date.now() - this.startTime;
+    const allTests = Object.values(this.testResults);
+    const totalPassed = allTests.reduce((sum, cat) => sum + cat.passed, 0);
+    const totalFailed = allTests.reduce((sum, cat) => sum + cat.failed, 0);
+    const totalTests = totalPassed + totalFailed;
+
+    console.log('\n' + '='.repeat(80));
+    console.log(chalk.bold.blue('📊 TEST SUITE REPORT'));
+    console.log('='.repeat(80));
+
+    // Summary
+    console.log(chalk.bold('\n📋 SUMMARY:'));
+    console.log(`Total Duration: ${(totalDuration / 1000).toFixed(2)}s`);
+    console.log(`Total Tests: ${totalTests}`);
+    console.log(`Passed: ${chalk.green(totalPassed)}`);
+    console.log(`Failed: ${chalk.red(totalFailed)}`);
+    console.log(`Success Rate: ${((totalPassed / totalTests) * 100).toFixed(1)}%`);
+
+    // Category breakdown
+    console.log(chalk.bold('\n📂 TEST CATEGORIES:'));
+
+    const categories = [
+      { name: 'Unit Tests', key: 'unit', icon: '🧪' },
+      { name: 'Integration Tests', key: 'integration', icon: '🔗' },
+      { name: 'Regression Tests', key: 'regression', icon: '🔄' },
+      { name: 'Performance Tests', key: 'performance', icon: '⚡' }
+    ];
+
+    categories.forEach(category => {
+      const results = this.testResults[category.key];
+      const success = results.failed === 0;
+      const status = success ? '✅' : '❌';
+      const color = success ? chalk.green : chalk.red;
+
+      console.log(`\n${category.icon} ${category.name}: ${status}`);
+      console.log(`  Tests: ${results.total}`);
+      console.log(`  Passed: ${color(results.passed)}`);
+      console.log(`  Failed: ${results.failed > 0 ? chalk.red(results.failed) : results.failed}`);
+      console.log(`  Duration: ${(results.duration / 1000).toFixed(2)}s`);
+    });
+
+    // Coverage information if available
+    const coveragePath = path.join(process.cwd(), 'coverage', 'coverage-summary.json');
+    if (fs.existsSync(coveragePath)) {
+      try {
+        const coverage = fs.readJsonSync(coveragePath);
+        console.log(chalk.bold('\n📈 COVERAGE SUMMARY:'));
+        console.log(`Lines: ${coverage.total.lines.pct}%`);
+        console.log(`Functions: ${coverage.total.functions.pct}%`);
+        console.log(`Branches: ${coverage.total.branches.pct}%`);
+        console.log(`Statements: ${coverage.total.statements.pct}%`);
+      } catch (error) {
+        this.log('Could not read coverage information', 'warning');
+      }
+    }
+
+    console.log('\n' + '='.repeat(80));
+
+    // Exit with appropriate code
+    const exitCode = totalFailed > 0 ? 1 : 0;
+
+    if (exitCode === 0) {
+      console.log(chalk.green.bold('\n🎉 ALL TESTS PASSED!'));
+    } else {
+      console.log(chalk.red.bold(`\n❌ ${totalFailed} TEST(S) FAILED!`));
+    }
+
+    return exitCode;
+  }
+
+  async runTestSuite() {
+    console.log(chalk.bold.blue('🚀 Starting HookDeploymentManager Test Suite'));
+    console.log(`Node.js version: ${process.version}`);
+    console.log(`Platform: ${process.platform}`);
+    console.log(`Working directory: ${process.cwd()}`);
+
+    try {
+      // Clean previous results
+      await fs.remove('coverage');
+      await fs.remove('test-results');
+
+      const unitSuccess = await this.runUnitTests();
+      const integrationSuccess = await this.runIntegrationTests();
+      const regressionSuccess = await this.runRegressionTests();
+
+      // Run performance tests only if others pass (to save time)
+      let performanceSuccess = true;
+      if (unitSuccess && integrationSuccess && regressionSuccess) {
+        performanceSuccess = await this.runPerformanceTests();
+      } else {
+        this.log('Skipping performance tests due to failures in other categories', 'warning');
+      }
+
+      // Generate report and exit
+      const exitCode = this.generateReport();
+      process.exit(exitCode);
+
+    } catch (error) {
+      this.log(`Test runner error: ${error.message}`, 'error');
+      console.error(error.stack);
+      process.exit(1);
+    }
+  }
+}
+
+// CLI interface
+if (require.main === module) {
+  const runner = new TestRunner();
+
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+HookDeploymentManager Test Runner
+
+Usage: node scripts/test-runner.js [options]
+
+Options:
+  --help, -h      Show this help message
+  --unit-only     Run only unit tests
+  --integration-only  Run only integration tests
+  --regression-only  Run only regression tests
+  --performance-only Run only performance tests
+  --no-performance Skip performance tests
+  --verbose       Enable verbose output
+
+Examples:
+  node scripts/test-runner.js                    # Run all tests
+  node scripts/test-runner.js --unit-only       # Run only unit tests
+  node scripts/test-runner.js --no-performance  # Skip performance tests
+    `);
+    process.exit(0);
+  }
+
+  // Handle specific test category requests
+  if (args.includes('--unit-only')) {
+    runner.runUnitTests().then(success => {
+      process.exit(success ? 0 : 1);
+    });
+  } else if (args.includes('--integration-only')) {
+    runner.runIntegrationTests().then(success => {
+      process.exit(success ? 0 : 1);
+    });
+  } else if (args.includes('--regression-only')) {
+    runner.runRegressionTests().then(success => {
+      process.exit(success ? 0 : 1);
+    });
+  } else if (args.includes('--performance-only')) {
+    runner.runPerformanceTests().then(success => {
+      process.exit(success ? 0 : 1);
+    });
+  } else {
+    // Run all tests
+    runner.runTestSuite();
+  }
+}
+
+module.exports = TestRunner;

package/src/cli/commands/autoinstall.js

@@ -0,0 +1,158 @@
+/**
+ * Auto-install Command
+ * Modular implementation for automated CLI tool installation (npm postinstall)
+ */
+
+const chalk = require('chalk');
+const { handleInstallCommand } = require('./install');
+
+/**
+ * Handle auto-install command - Automated installation for npm postinstall
+ * @param {Object} options - Command options
+ */
+async function handleAutoInstallCommand(options = {}) {
+  try {
+    // Detect npm environment for better output visibility
+    const isNpmPostinstall = process.env.npm_lifecycle_event === 'postinstall';
+
+    // Use stderr for critical messages in npm environment (more likely to be shown)
+    const criticalLog = isNpmPostinstall ? console.error : console.log;
+
+    criticalLog(chalk.cyan('🚀 STIGMERGY CLI AUTO-INSTALL STARTING'));
+    criticalLog('='.repeat(60));
+    criticalLog('Installing cross-CLI integration and scanning for AI tools...');
+    criticalLog('='.repeat(60));
+
+    console.log(chalk.blue('[AUTO-INSTALL] Stigmergy CLI automated setup'));
+    console.log('='.repeat(60));
+
+    // Check if we're in npm postinstall environment
+    if (isNpmPostinstall) {
+      console.log(chalk.yellow('📦 Detected npm postinstall environment'));
+      console.log(chalk.gray('Setting up CLI integrations automatically...'));
+    }
+
+    // Auto-install options - non-interactive mode
+    const autoInstallOptions = {
+      cli: 'all', // Install all available CLI tools
+      verbose: options.verbose || process.env.DEBUG === 'true',
+      force: options.force || false,
+      nonInteractive: true, // Critical for automated installation
+      autoDetect: true, // Auto-detect available tools
+      skipPermissionCheck: process.env.STIGMERGY_SKIP_PERMISSION_CHECK === 'true'
+    };
+
+    console.log(chalk.blue('🔍 Scanning for available CLI tools...'));
+
+    // Run the installation
+    console.log(chalk.blue('🛠️  Starting automated CLI tool installation...'));
+
+    const installResult = await handleInstallCommand(autoInstallOptions);
+
+    if (installResult.success) {
+      console.log(chalk.green('\n✅ Auto-install completed successfully!'));
+
+      if (isNpmPostinstall) {
+        criticalLog(chalk.green('✅ STIGMERGY CLI SETUP COMPLETE'));
+        criticalLog(chalk.gray('You can now use: stigmergy <tool> <command>'));
+      }
+
+      // Show summary of what was installed
+      if (installResult.installed && installResult.installed.length > 0) {
+        console.log(chalk.blue('\n📋 Installation Summary:'));
+        installResult.installed.forEach(tool => {
+          console.log(`  ${chalk.green('✅')} ${tool}`);
+        });
+      }
+
+      if (installResult.failed && installResult.failed.length > 0) {
+        console.log(chalk.blue('\n❌ Failed Tools:'));
+        installResult.failed.forEach(tool => {
+          console.log(`  ${chalk.red('❌')} ${tool} (installation failed)`);
+        });
+      }
+
+      if (installResult.existing && installResult.existing.length > 0) {
+        console.log(chalk.blue('\n🔧 Already Available:'));
+        installResult.existing.forEach(tool => {
+          console.log(`  ${chalk.yellow('⚠️')} ${tool} (already installed)`);
+        });
+      }
+
+    } else {
+      console.log(chalk.red('\n❌ Auto-install encountered issues'));
+
+      if (isNpmPostinstall) {
+        criticalLog(chalk.red('❌ STIGMERGY CLI SETUP INCOMPLETE'));
+        criticalLog(chalk.yellow('Run: stigmergy install to complete setup manually'));
+      }
+
+      if (installResult.error) {
+        console.log(chalk.red(`Error: ${installResult.error}`));
+      }
+    }
+
+    // Setup verification
+    console.log(chalk.blue('\n🔍 Verifying installation...'));
+
+    // Quick verification of core functionality
+    const verificationChecks = [
+      { name: 'Core modules accessible', check: () => require('../utils/formatters') && require('../utils/environment') },
+      { name: 'Error handler available', check: () => require('../../core/error_handler') },
+      { name: 'Smart router available', check: () => require('../../core/smart_router') }
+    ];
+
+    let verificationPassed = 0;
+    for (const check of verificationChecks) {
+      try {
+        check.check();
+        console.log(`  ${chalk.green('✅')} ${check.name}`);
+        verificationPassed++;
+      } catch (error) {
+        console.log(`  ${chalk.red('❌')} ${check.name}`);
+      }
+    }
+
+    if (verificationPassed === verificationChecks.length) {
+      console.log(chalk.green('\n✅ All verification checks passed!'));
+
+      if (isNpmPostinstall) {
+        criticalLog(chalk.green('🎉 STIGMERGY CLI IS READY TO USE!'));
+      }
+    } else {
+      console.log(chalk.yellow('\n⚠️  Some verification checks failed'));
+      console.log(chalk.yellow('Run: stigmergy diagnostic for full system check'));
+    }
+
+    // Final summary for npm environment
+    if (isNpmPostinstall) {
+      criticalLog('='.repeat(60));
+      criticalLog(chalk.cyan('🎯 STIGMERGY CLI AUTO-INSTALL FINISHED'));
+      criticalLog('='.repeat(60));
+    }
+
+    return {
+      success: installResult.success,
+      verificationPassed,
+      installed: installResult.installed || [],
+      existing: installResult.existing || []
+    };
+
+  } catch (error) {
+    const isNpmPostinstall = process.env.npm_lifecycle_event === 'postinstall';
+    const criticalLog = isNpmPostinstall ? console.error : console.log;
+
+    console.error(chalk.red('[ERROR] Auto-install failed:'), error.message);
+
+    if (isNpmPostinstall) {
+      criticalLog(chalk.red('💥 AUTO-INSTALL FAILED'));
+      criticalLog(chalk.yellow('Run: stigmergy install --verbose for detailed installation'));
+    }
+
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  handleAutoInstallCommand
+};

package/src/cli/commands/errors.js

@@ -0,0 +1,190 @@
+/**
+ * Error Reporting Commands
+ * Modular implementation for error reporting and system troubleshooting
+ */
+
+const chalk = require('chalk');
+const { errorHandler } = require('../../core/error_handler');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+/**
+ * Handle errors command - Generate comprehensive error report
+ * @param {Object} options - Command options
+ */
+async function handleErrorsCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[ERRORS] Generating Stigmergy CLI error report...\n'));
+
+    const report = {
+      timestamp: new Date().toISOString(),
+      system: {},
+      environment: {},
+      errors: [],
+      diagnostics: {}
+    };
+
+    // System information
+    console.log(chalk.blue('🖥️  System Information:'));
+    report.system = {
+      platform: os.platform(),
+      arch: os.arch(),
+      nodeVersion: process.version,
+      memory: Math.round(os.totalmem() / 1024 / 1024) + ' MB',
+      freeMemory: Math.round(os.freemem() / 1024 / 1024) + ' MB'
+    };
+
+    Object.entries(report.system).forEach(([key, value]) => {
+      console.log(`  ${key}: ${chalk.green(value)}`);
+    });
+
+    // Environment information
+    console.log(chalk.blue('\n🌍 Environment Information:'));
+    report.environment = {
+      pwd: process.cwd(),
+      home: os.homedir(),
+      shell: process.env.SHELL || process.env.COMSPEC || 'unknown',
+      path: process.env.PATH ? process.env.PATH.split(path.delimiter).slice(0, 3).join(path.delimiter) + '...' : 'unknown',
+      nodeEnv: process.env.NODE_ENV || 'undefined',
+      debugMode: process.env.DEBUG === 'true'
+    };
+
+    Object.entries(report.environment).forEach(([key, value]) => {
+      console.log(`  ${key}: ${chalk.green(value)}`);
+    });
+
+    // Error handler report (if available)
+    console.log(chalk.blue('\n📋 Error Handler Report:'));
+    try {
+      if (errorHandler && typeof errorHandler.printErrorReport === 'function') {
+        await errorHandler.printErrorReport();
+        console.log(chalk.green('  ✅ Error handler report generated'));
+      } else {
+        console.log(chalk.yellow('  ⚠️  Error handler not available'));
+      }
+    } catch (error) {
+      console.log(chalk.red(`  ❌ Error handler failed: ${error.message}`));
+      report.errors.push({
+        type: 'error_handler',
+        message: error.message,
+        timestamp: new Date().toISOString()
+      });
+    }
+
+    // Check for common issues
+    console.log(chalk.blue('\n🔍 Common Issues Check:'));
+
+    const checks = [
+      {
+        name: 'Current directory writable',
+        check: async () => {
+          try {
+            await fs.access(process.cwd(), fs.constants.W_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      },
+      {
+        name: 'Home directory accessible',
+        check: async () => {
+          try {
+            await fs.access(os.homedir(), fs.constants.R_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      },
+      {
+        name: 'Node modules accessible',
+        check: async () => {
+          try {
+            await fs.access(path.join(process.cwd(), 'node_modules'), fs.constants.R_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      },
+      {
+        name: 'Package.json exists',
+        check: async () => {
+          try {
+            await fs.access(path.join(process.cwd(), 'package.json'), fs.constants.R_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      }
+    ];
+
+    for (const check of checks) {
+      try {
+        const passed = await check.check();
+        const icon = passed ? chalk.green('✅') : chalk.red('❌');
+        console.log(`  ${icon} ${check.name}`);
+
+        if (!passed) {
+          report.errors.push({
+            type: 'common_issue',
+            message: `${check.name} failed`,
+            timestamp: new Date().toISOString()
+          });
+        }
+      } catch (error) {
+        console.log(`  ${chalk.yellow('⚠️')} ${check.name} - Check failed`);
+      }
+    }
+
+    // Log files check
+    console.log(chalk.blue('\n📄 Log Files:'));
+    const logLocations = [
+      path.join(os.homedir(), '.stigmergy', 'logs'),
+      path.join(process.cwd(), 'logs'),
+      path.join(os.tmpdir(), 'stigmergy-logs')
+    ];
+
+    for (const logLocation of logLocations) {
+      try {
+        const stats = await fs.stat(logLocation);
+        console.log(`  ${chalk.green('✅')} ${logLocation} (${stats.size} bytes)`);
+      } catch {
+        console.log(`  ${chalk.gray('⚪')} ${logLocation} (not found)`);
+      }
+    }
+
+    // Summary
+    console.log(chalk.blue('\n📊 Error Report Summary:'));
+    const errorCount = report.errors.length;
+    const warningCount = report.environment.debugMode ? 1 : 0;
+
+    console.log(`  Errors: ${chalk.red(errorCount)}`);
+    console.log(`  Warnings: ${chalk.yellow(warningCount)}`);
+
+    if (errorCount === 0) {
+      console.log(chalk.green('\n✅ No critical errors detected!'));
+    } else {
+      console.log(chalk.red(`\n❌ ${errorCount} issue(s) found - see details above`));
+    }
+
+    // Save report to file if requested
+    if (options.save) {
+      const reportPath = path.join(process.cwd(), `stigmergy-error-report-${Date.now()}.json`);
+      await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+      console.log(chalk.blue(`\n💾 Report saved to: ${reportPath}`));
+    }
+
+    return { success: true, report };
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Failed to generate error report:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  handleErrorsCommand
+};