stigmergy 1.3.2-beta.0 → 1.3.2-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stigmergy",
-  "version": "1.3.2-beta.0",
+  "version": "1.3.2-beta.2",
   "description": "Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System",
   "main": "src/index.js",
   "bin": {
@@ -48,6 +48,8 @@
     "path-fixer": "node path-fixer.js",
     "emergency-clean": "node emergency-cleanup.js",
     "test:conflict-prevention": "node test/conflict-prevention-test.js",
+    "test:comprehensive": "node scripts/run-comprehensive-tests.js",
+    "test:quick": "node scripts/run-quick-tests.js",
     "post-deployment-config": "node scripts/post-deployment-config.js",
     "preinstall": "node scripts/preinstall-check.js",
     "postinstall": "node src/index.js auto-install",

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

package/src/cli/commands/project.js

@@ -150,7 +150,7 @@ async function handleInitCommand(options = {}) {
 
     // Create basic config
     const config = {
-      version: '1.3.0-beta.0',
+      version: '1.3.2-beta.2',
       created: new Date().toISOString(),
       project: path.basename(projectDir)
     };

package/src/cli/router-beta.js

@@ -95,7 +95,7 @@ async function main() {
 
   // Program setup
   program
-    .version('1.3.0-beta.0')
+    .version('1.3.2-beta.2')
     .description('Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System')
     .name('stigmergy');
 

package/src/core/coordination/nodejs/HookDeploymentManager.js

@@ -76,6 +76,11 @@ class HookDeploymentManager {
   async deployNodeJsHooks(cliName, hookDir, options) {
     console.log(`[HOOK_DEPLOYMENT] Deploying Node.js hooks for ${cliName}...`);
 
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
+    }
+
     // Deploy ResumeSession extension
     await this.deployResumeSessionExtension(cliName, hookDir);
 
@@ -92,6 +97,11 @@ class HookDeploymentManager {
   async deployResumeSessionExtension(cliName, hookDir) {
     console.log(`[HOOK_DEPLOYMENT] Deploying ResumeSession extension for ${cliName}...`);
 
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
+    }
+
     try {
       const extensionContent = this.resumeSessionGenerator.generateForCLI(cliName);
       const fileName = this.resumeSessionGenerator.getFileName(cliName);
@@ -120,6 +130,11 @@ class HookDeploymentManager {
   async deploySkillsIntegration(cliName, hookDir) {
     console.log(`[HOOK_DEPLOYMENT] Deploying skills integration for ${cliName}...`);
 
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
+    }
+
     try {
       const skillsResult = this.skillsIntegrationGenerator.generateForCLI(cliName);
       const skillsPath = path.join(hookDir, skillsResult.fileName);
@@ -158,6 +173,11 @@ class HookDeploymentManager {
   async deployCLIAdapter(cliName, hookDir) {
     console.log(`[HOOK_DEPLOYMENT] Deploying CLI adapter for ${cliName}...`);
 
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
+    }
+
     try {
       const adapterContent = this.cliAdapterGenerator.generateForCLI(cliName);
       const fileName = this.cliAdapterGenerator.getFileName(cliName);
@@ -184,6 +204,11 @@ class HookDeploymentManager {
   async createBasicConfiguration(cliName, hookDir) {
     console.log(`[HOOK_DEPLOYMENT] Creating basic configuration for ${cliName}...`);
 
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
+    }
+
     try {
       // Create main configuration file
       const config = {

package/src/core/coordination/nodejs/generators/ResumeSessionGenerator.js

@@ -332,12 +332,14 @@ class SessionFilter {
       switch (timeRange) {
         case 'today':
           return sessionDate.toDateString() === now.toDateString();
-        case 'week':
+        case 'week': {
           const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
           return sessionDate >= weekAgo;
-        case 'month':
+        }
+        case 'month': {
           const monthAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
           return sessionDate >= monthAgo;
+        }
         default:
           return true;
       }
@@ -565,11 +567,11 @@ function buildQuery(input) {
 
 // CLI-specific registration logic
 
-${this.generateCLIRegistrationCode(cliName, commandName)}
+${this.generateCLIRegistrationCode(cliName, commandName, projectPath)}
 `;
   }
 
-  generateCLIRegistrationCode(cliName, commandName) {
+  generateCLIRegistrationCode(cliName, commandName, projectPath) {
     switch (cliName.toLowerCase()) {
       case 'claude':
       case 'codebuddy':

package/src/core/enhanced_cli_installer.js

@@ -24,13 +24,18 @@ class EnhancedCLIInstaller {
       ...options
     };
 
+    // Expose commonly used options as properties for easier access
+    this.verbose = this.options.verbose;
+    this.force = options.force || false;
+    this.homeDir = options.homeDir || require('os').homedir();
     this.results = {
       permissionSetup: null,
       installations: {},
       failedInstallations: [],
       npmConfigured: false,
       workingDirectory: null,
-      permissionMode: 'standard' // 'standard', 'elevated', 'failed'
+      permissionMode: 'standard', // 'standard', 'elevated', 'failed'
+      errors: []
     };
 
     this.cliTools = require('./cli_tools').CLI_TOOLS;
@@ -794,6 +799,155 @@ class EnhancedCLIInstaller {
   getResults() {
     return this.results;
   }
+
+  /**
+   * Detect permission availability for the current platform
+   */
+  detectPermissionAvailability() {
+    const platform = process.platform;
+
+    if (platform === 'win32') {
+      // Windows: Check if running as administrator
+      try {
+        const { execSync } = require('child_process');
+        const result = execSync('net session', { encoding: 'utf8' });
+        return result.includes('Administrator');
+      } catch {
+        return false;
+      }
+    } else {
+      // Unix-like systems: Check available privilege escalation tools
+      const privilegeEscalationTools = ['sudo', 'doas', 'run0', 'pkexec'];
+      for (const tool of privilegeEscalationTools) {
+        try {
+          const result = spawnSync(tool, ['--version'], {
+            stdio: 'pipe',
+            timeout: 5000
+          });
+          if (result.status !== null || result.error?.code !== 'ENOENT') {
+            return true;
+          }
+        } catch {
+          continue;
+        }
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Detect available privilege escalation tools
+   */
+  detectPrivilegeTools() {
+    const platform = process.platform;
+    const availableTools = [];
+
+    if (platform === 'win32') {
+      // Windows: Check for admin privileges
+      try {
+        const { execSync } = require('child_process');
+        const result = execSync('net session', { encoding: 'utf8' });
+        if (result.includes('Administrator')) {
+          availableTools.push('admin');
+        }
+      } catch {
+        // Not running as admin
+      }
+    } else {
+      // Unix-like systems: Check privilege escalation tools
+      const tools = [
+        { name: 'sudo', checkCmd: ['-n', 'true'] },
+        { name: 'doas', checkCmd: ['-n', 'true'] },
+        { name: 'run0', checkCmd: ['-n', 'true'] },
+        { name: 'pkexec', checkCmd: ['--help'] }
+      ];
+
+      for (const tool of tools) {
+        try {
+          const result = spawnSync(tool.name, tool.checkCmd, {
+            stdio: 'pipe',
+            timeout: 5000
+          });
+          if (result.status !== null || result.error?.code !== 'ENOENT') {
+            availableTools.push(tool.name);
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+
+    return availableTools;
+  }
+
+  /**
+   * Upgrade a single tool
+   */
+  async upgradeTool(toolName, toolInfo) {
+    this.log('info', `Upgrading ${toolName}...`);
+
+    if (!toolInfo || !toolInfo.install) {
+      this.log('warn', `Tool ${toolName} has no install command, skipping upgrade...`);
+      this.results.errors.push({
+        tool: toolName,
+        error: 'No install command specified',
+        timestamp: new Date().toISOString()
+      });
+      return false;
+    }
+
+    const upgradeCommand = `npm upgrade -g ${toolName}`;
+
+    this.results.installations[toolName] = {
+      startTime: Date.now(),
+      ...this.results.installations[toolName]
+    };
+
+    try {
+      const success = await this.installTool(toolName, {
+        ...toolInfo,
+        install: upgradeCommand,
+        name: `${toolInfo.name} (Upgrade)`
+      });
+
+      return success;
+    } catch (error) {
+      this.log('error', `Failed to upgrade ${toolName}: ${error.message}`);
+      this.results.errors.push({
+        tool: toolName,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Get installation summary
+   */
+  getInstallationSummary() {
+    const installations = this.results.installations || {};
+    const errors = this.results.errors || [];
+
+    const total = Object.keys(installations).length;
+    const successful = Object.values(installations).filter(i => i.success !== false).length;
+    const failed = total - successful;
+
+    return {
+      total,
+      successful,
+      failed,
+      permissionMode: this.permissionMode,
+      npmConfigured: this.results.npmConfigured,
+      workingDirectory: this.results.workingDirectory,
+      errors: errors.map(e => ({
+        tool: e.tool,
+        error: e.error,
+        timestamp: e.timestamp
+      })),
+      details: installations
+    };
+  }
 }
 
 module.exports = EnhancedCLIInstaller;

package/src/core/installer.js

@@ -211,6 +211,12 @@ class StigmergyInstaller extends EnhancedCLIInstaller {
     const missing = {};
 
     for (const [toolName, toolInfo] of Object.entries(this.router.tools)) {
+      // Skip internal functions without install command
+      if (!toolInfo.install) {
+        console.log(`[DEBUG] Tool ${toolName} has no version/install info, skipping check`);
+        continue;
+      }
+
       try {
         console.log(`[SCAN] Checking ${toolInfo.name}...`);
         const isAvailable = await this.checkCLI(toolName);
@@ -335,6 +341,35 @@ class StigmergyInstaller extends EnhancedCLIInstaller {
     return result;
   }
 
+  /**
+   * Generate hook for a specific CLI tool
+   * @param {string} toolName - Name of the CLI tool
+   * @param {Object} toolInfo - Tool information object
+   */
+  async generateToolHook(toolName, toolInfo) {
+    console.log(`[HOOK] Generating hook for ${toolName}...`);
+
+    const HookDeploymentManager = require('./coordination/nodejs/HookDeploymentManager');
+    const hookManager = new HookDeploymentManager();
+
+    await hookManager.initialize();
+
+    try {
+      const deploySuccess = await hookManager.deployHooksForCLI(toolName);
+
+      if (deploySuccess) {
+        console.log(`[OK] Hook generated successfully for ${toolName}`);
+        return true;
+      } else {
+        console.log(`[WARN] Hook generation failed for ${toolName}`);
+        return false;
+      }
+    } catch (error) {
+      console.error(`[ERROR] Hook generation error for ${toolName}:`, error.message);
+      throw error;
+    }
+  }
+
   /**
    * Deploy hooks for available CLI tools
    */