stigmergy 1.2.12 → 1.3.1-beta

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/run-comprehensive-tests.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+/**
+ * Comprehensive Test Runner
+ * Runs all tests and generates detailed coverage report
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+console.log('🎯 COMPREHENSIVE TEST SUITE');
+console.log('='.repeat(70));
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function runCommand(command, description) {
+  log(`\n📦 ${description}...`, 'cyan');
+
+  try {
+    const output = execSync(command, {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+    log(`✅ ${description} completed`, 'green');
+    return true;
+  } catch (error) {
+    log(`❌ ${description} failed`, 'red');
+    log(`Error: ${error.message}`, 'red');
+    return false;
+  }
+}
+
+function ensureDirectories() {
+  const dirs = [
+    'tests/comprehensive/cli',
+    'tests/comprehensive/cli/commands',
+    'tests/comprehensive/core',
+    'tests/comprehensive/coordination',
+    'tests/comprehensive/adapters',
+    'tests/comprehensive/utils',
+    'coverage'
+  ];
+
+  dirs.forEach(dir => {
+    const fullPath = path.join(process.cwd(), dir);
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+  });
+}
+
+function countTestFiles() {
+  const testDirs = [
+    'tests/unit',
+    'tests/integration',
+    'tests/e2e',
+    'tests/comprehensive',
+    'tests/regression'
+  ];
+
+  let totalTests = 0;
+  testDirs.forEach(dir => {
+    const testPath = path.join(process.cwd(), dir);
+    if (fs.existsSync(testPath)) {
+      const files = fs.readdirSync(testPath)
+        .filter(f => f.endsWith('.test.js'));
+      totalTests += files.length;
+    }
+  });
+
+  return totalTests;
+}
+
+function countSourceFiles() {
+  const srcPath = path.join(process.cwd(), 'src');
+
+  function countDir(dir) {
+    let count = 0;
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+
+    items.forEach(item => {
+      if (item.isDirectory()) {
+        count += countDir(path.join(dir, item.name));
+      } else if (item.name.endsWith('.js')) {
+        count++;
+      }
+    });
+
+    return count;
+  }
+
+  return countDir(srcPath);
+}
+
+function printSummary() {
+  log('\n' + '='.repeat(70), 'cyan');
+  log('📊 TEST SUITE SUMMARY', 'cyan');
+  log('='.repeat(70), 'cyan');
+
+  const sourceFiles = countSourceFiles();
+  const testFiles = countTestFiles();
+  const coverage = ((testFiles / sourceFiles) * 100).toFixed(1);
+
+  log(`\n📁 Source Files: ${sourceFiles}`);
+  log(`🧪 Test Files: ${testFiles}`);
+  log(`📈 Test Coverage: ${coverage}%`);
+
+  log('\n' + '='.repeat(70), 'cyan');
+}
+
+function readCoverageReport() {
+  const coveragePath = path.join(process.cwd(), 'coverage', 'coverage-summary.json');
+
+  if (!fs.existsSync(coveragePath)) {
+    log('\n⚠️  Coverage report not found', 'yellow');
+    return;
+  }
+
+  const coverage = JSON.parse(fs.readFileSync(coveragePath, 'utf8'));
+
+  log('\n' + '='.repeat(70), 'cyan');
+  log('📊 DETAILED COVERAGE REPORT', 'cyan');
+  log('='.repeat(70), 'cyan');
+
+  const total = coverage.total;
+  log(`\n📈 Overall Coverage:`, 'cyan');
+  log(`   Statements: ${total.statements.pct}% (${total.statements.covered}/${total.statements.total})`);
+  log(`   Branches:   ${total.branches.pct}% (${total.branches.covered}/${total.branches.total})`);
+  log(`   Functions:  ${total.functions.pct}% (${total.functions.covered}/${total.functions.total})`);
+  log(`   Lines:      ${total.lines.pct}% (${total.lines.covered}/${total.lines.total})`);
+
+  // Find files with low coverage
+  log('\n📉 Files with Low Coverage (< 80%):', 'yellow');
+  let lowCoverageFound = false;
+
+  Object.entries(coverage).forEach(([file, data]) => {
+    if (file !== 'total' && data.statements.pct < 80) {
+      lowCoverageFound = true;
+      const relativePath = file.replace(process.cwd(), '');
+      log(`   ${relativePath}: ${data.statements.pct}%`, 'red');
+    }
+  });
+
+  if (!lowCoverageFound) {
+    log('   ✅ All files have good coverage!', 'green');
+  }
+
+  log('\n' + '='.repeat(70), 'cyan');
+}
+
+async function main() {
+  const startTime = Date.now();
+
+  try {
+    // Ensure test directories exist
+    ensureDirectories();
+
+    // Print initial summary
+    log('\n🔍 Test Environment:', 'blue');
+    log(`   Node.js: ${process.version}`);
+    log(`   Platform: ${process.platform}`);
+    log(`   CWD: ${process.cwd()}`);
+
+    // Run pre-test cleanup
+    log('\n🧹 Cleaning test environment...', 'blue');
+    try {
+      execSync('npm run clean 2>/dev/null || true', { stdio: 'ignore' });
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    // Run tests by category
+    const results = {
+      unit: runCommand('npm run test:unit -- --silent', 'Unit Tests'),
+      integration: runCommand('npm run test:integration -- --silent', 'Integration Tests'),
+      comprehensive: runCommand('jest tests/comprehensive --coverage --silent', 'Comprehensive Tests')
+    };
+
+    // Generate coverage report
+    if (results.comprehensive) {
+      readCoverageReport();
+    }
+
+    // Calculate duration
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+
+    // Print final summary
+    printSummary();
+
+    log(`\n⏱️  Total Duration: ${duration}s`, 'blue');
+
+    // Determine success
+    const allPassed = Object.values(results).every(r => r === true);
+
+    if (allPassed) {
+      log('\n✅ ALL TESTS PASSED!', 'green');
+      log('\n🎉 Great job! Your test suite is comprehensive.', 'green');
+      process.exit(0);
+    } else {
+      log('\n❌ SOME TESTS FAILED', 'red');
+      log('\n💡 Run with --verbose to see detailed error messages', 'yellow');
+      process.exit(1);
+    }
+
+  } catch (error) {
+    log(`\n💥 Fatal Error: ${error.message}`, 'red');
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// Run if executed directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { runCommand, readCoverageReport, printSummary };

package/scripts/run-quick-tests.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * Quick Test Runner
+ * Runs only the comprehensive tests without legacy tests
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+console.log('🎯 QUICK COMPREHENSIVE TEST SUITE');
+console.log('='.repeat(70));
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function runCommand(command, description) {
+  log(`\n📦 ${description}...`, 'cyan');
+
+  try {
+    const output = execSync(command, {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+    log(`✅ ${description} completed`, 'green');
+    return true;
+  } catch (error) {
+    log(`❌ ${description} failed`, 'red');
+    return false;
+  }
+}
+
+async function main() {
+  const startTime = Date.now();
+
+  try {
+    log('\n🔍 Running comprehensive tests only...', 'blue');
+
+    // Ensure directories exist
+    const dirs = ['tests/comprehensive/cli/commands', 'tests/comprehensive/core', 'tests/comprehensive/coordination'];
+    dirs.forEach(dir => {
+      const fullPath = path.join(process.cwd(), dir);
+      if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+      }
+    });
+
+    // Run comprehensive tests only
+    const result = runCommand(
+      'jest tests/comprehensive --coverage',
+      'Comprehensive Tests'
+    );
+
+    // Calculate duration
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+
+    log(`\n⏱️  Duration: ${duration}s`, 'blue');
+
+    if (result) {
+      log('\n✅ ALL TESTS PASSED!', 'green');
+      process.exit(0);
+    } else {
+      log('\n❌ SOME TESTS FAILED', 'red');
+      log('\n💡 Check the output above for details', 'yellow');
+      process.exit(1);
+    }
+
+  } catch (error) {
+    log(`\n💥 Fatal Error: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { runCommand };