stigmergy 1.2.13 → 1.3.2-beta.0

package/scripts/analyze-router.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+/**
+ * Router.js Structure Analysis Tool
+ * Analyzes the router.js file to identify modularization opportunities
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('🔍 Router.js Structure Analysis');
+console.log('='.repeat(50));
+
+const routerPath = path.join(__dirname, '../src/cli/router.js');
+
+if (!fs.existsSync(routerPath)) {
+  console.error('❌ router.js file not found');
+  process.exit(1);
+}
+
+const content = fs.readFileSync(routerPath, 'utf8');
+const lines = content.split('\n');
+
+console.log(`📄 Total Lines: ${lines.length}`);
+console.log(`📏 File Size: ${(fs.statSync(routerPath).size / 1024).toFixed(2)} KB`);
+console.log('');
+
+// Analyze imports
+console.log('📦 Import Analysis:');
+const importRegex = /const\s+(.+?)\s*=\s*require\(['"](.+?)['"]\)/g;
+const imports = [];
+let match;
+
+while ((match = importRegex.exec(content)) !== null) {
+  imports.push({
+    name: match[1],
+    path: match[2],
+    line: content.substring(0, match.index).split('\n').length
+  });
+}
+
+console.log(`Found ${imports.length} imports:`);
+imports.forEach(imp => {
+  console.log(`  📋 ${imp.name} <- ${imp.path} (line ${imp.line})`);
+});
+
+// Analyze functions
+console.log('\n🔧 Function Analysis:');
+const functionRegex = /(?:function\s+(\w+)|const\s+(\w+)\s*=\s*(?:async\s+)?(?:function|\([^)]*\)\s*=>))/g;
+const functions = [];
+let funcMatch;
+
+while ((funcMatch = functionRegex.exec(content)) !== null) {
+  const funcName = funcMatch[1] || funcMatch[2];
+  const funcStart = content.substring(0, funcMatch.index).split('\n').length;
+  functions.push({
+    name: funcName,
+    line: funcStart,
+    isAsync: content.includes('async') && content.substring(funcMatch.index - 50, funcMatch.index).includes('async')
+  });
+}
+
+console.log(`Found ${functions.length} functions:`);
+functions.forEach(func => {
+  console.log(`  ⚙️  ${func.name}${func.isAsync ? ' (async)' : ''} (line ${func.line})`);
+});
+
+// Analyze main sections
+console.log('\n📂 Section Analysis:');
+
+// Look for main sections
+const sections = [
+  { name: 'Import Section', pattern: /const.*require/ },
+  { name: 'Setup Section', pattern: /setupGlobalErrorHandlers|program\.version/ },
+  { name: 'Command Definitions', pattern: /program\.command/ },
+  { name: 'CLI Tools Routing', pattern: /SmartRouter|routeToCLI/ },
+  { name: 'Error Handling', pattern: /errorHandler|catch.*error/ },
+  { name: 'Helper Functions', pattern: /function formatBytes|function getWorkingDirectory/ },
+  { name: 'Main Execution', pattern: /async function main|if \(require\.main/ }
+];
+
+sections.forEach(section => {
+  const sectionMatch = content.match(section.pattern);
+  if (sectionMatch) {
+    const lineNum = content.substring(0, sectionMatch.index).split('\n').length;
+    console.log(`  📑 ${section.name} (around line ${lineNum})`);
+  }
+});
+
+// Look for command definitions
+console.log('\n🎯 Command Definitions:');
+const commandRegex = /program\.command\(['"]([^'"]+)['"]\)/g;
+const commands = [];
+let cmdMatch;
+
+while ((cmdMatch = commandRegex.exec(content)) !== null) {
+  commands.push(cmdMatch[1]);
+}
+
+console.log(`Found ${commands.length} CLI commands:`);
+commands.forEach(cmd => {
+  console.log(`  💻 ${cmd}`);
+});
+
+// Look for CLI tools routing
+console.log('\n🛣️ CLI Tools Routing:');
+const toolRegex = /(?:case|if).*['"]([^'"]+)['"].*?:/g;
+const tools = [];
+let toolMatch;
+
+while ((toolMatch = toolRegex.exec(content)) !== null) {
+  const tool = toolMatch[1];
+  if (!tools.includes(tool) && ['claude', 'gemini', 'qwen', 'codebuddy', 'codex', 'iflow', 'qodercli', 'copilot'].includes(tool)) {
+    tools.push(tool);
+  }
+}
+
+console.log(`Found routing for ${tools.length} CLI tools:`);
+tools.forEach(tool => {
+  console.log(`  🔗 ${tool}`);
+});
+
+// Suggest modularization strategy
+console.log('\n💡 Modularization Suggestions:');
+console.log('');
+
+console.log('🏗️  Recommended Module Structure:');
+console.log('  src/cli/');
+console.log('  ├── router.js (main entry, ~200 lines)');
+console.log('  ├── commands/');
+console.log('  │   ├── index.js (command registry)');
+console.log('  │   ├── install.js (install commands)');
+console.log('  │   ├── status.js (status commands)');
+console.log('  │   ├── scan.js (scan commands)');
+console.log('  │   └── deploy.js (deploy commands)');
+console.log('  ├── routing/');
+console.log('  │   ├── index.js (routing coordinator)');
+console.log('  │   ├── cli-router.js (CLI tools routing)');
+console.log('  │   └── command-router.js (command routing)');
+console.log('  ├── utils/');
+console.log('  │   ├── formatters.js (format helpers)');
+console.log('  │   ├── validators.js (input validation)');
+console.log('  │   └── executors.js (command execution)');
+console.log('  └── config/');
+console.log('      ├── program-setup.js (commander setup)');
+console.log('      └── environment.js (environment setup)');
+
+console.log('');
+console.log('🎯 TDD Migration Strategy:');
+console.log('  1. ✅ Create comprehensive test suite for current router.js');
+console.log('  2. 🔄 Extract helper functions first (low risk)');
+console.log('  3. 🔄 Extract command definitions (medium risk)');
+console.log('  4. 🔄 Extract CLI routing logic (medium risk)');
+console.log('  5. 🔄 Create modular command handlers (high risk)');
+console.log('  6. ✅ Maintain backward compatibility');
+console.log('  7. ✅ Create rollback mechanism');
+
+console.log('');
+console.log('⚠️  Risk Assessment:');
+console.log('  🟢 LOW: Helper functions (formatBytes, etc.)');
+console.log('  🟡 MEDIUM: Command definitions and routing');
+console.log('  🔴 HIGH: Core CLI execution logic');
+console.log('');
+console.log('🛡️  Safety Measures:');
+console.log('  ✅ Backup original file');
+console.log('  ✅ Create feature branch');
+console.log('  ✅ Test before and after each extraction');
+console.log('  ✅ Gradual migration with rollback points');

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
+};