stigmergy 1.2.0 → 1.2.6

package/src/deploy.js

@@ -1,55 +1,55 @@
-#!/usr/bin/env node
-
-/**
- * Stigmergy Deployment Script
- * This script deploys hooks and integrations for all available CLI tools
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-
-// Import the main Stigmergy installer
-const { StigmergyInstaller } = require('./main_english.js');
-
-// Set up global error handlers using our error handler module
-const { setupGlobalErrorHandlers } = require('./core/error_handler');
-setupGlobalErrorHandlers();
-
-async function deploy() {
-  console.log('Stigmergy Deployment Script');
-  console.log('==========================');
-
-  try {
-    // Create installer instance
-    const installer = new StigmergyInstaller();
-
-    // Scan for available tools
-    console.log('[SCAN] Scanning for available CLI tools...');
-    const scanResult = await installer.scanCLI();
-    const available = scanResult.available;
-
-    // Deploy hooks for all available tools
-    console.log('[DEPLOY] Deploying hooks for all available tools...');
-    await installer.deployHooks(available);
-
-    console.log('\n[SUCCESS] Deployment completed successfully!');
-    return true;
-  } catch (error) {
-    console.error('[ERROR] Deployment failed:', error.message);
-    return false;
-  }
-}
-
-// Run deployment if called directly
-if (require.main === module) {
-  deploy()
-    .then((success) => {
-      process.exit(success ? 0 : 1);
-    })
-    .catch((error) => {
-      console.error('[FATAL ERROR]:', error.message);
-      process.exit(1);
-    });
-}
-
-module.exports = { deploy };
+#!/usr/bin/env node
+
+/**
+ * Stigmergy Deployment Script
+ * This script deploys hooks and integrations for all available CLI tools
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+// Import the main Stigmergy installer
+const StigmergyInstaller = require('./core/installer');
+
+// Set up global error handlers using our error handler module
+const { setupGlobalErrorHandlers } = require('./core/error_handler');
+setupGlobalErrorHandlers();
+
+async function deploy() {
+  console.log('Stigmergy Deployment Script');
+  console.log('==========================');
+
+  try {
+    // Create installer instance
+    const installer = new StigmergyInstaller();
+
+    // Scan for available tools
+    console.log('[SCAN] Scanning for available CLI tools...');
+    const scanResult = await installer.scanCLI();
+    const available = scanResult.available;
+
+    // Deploy hooks for all available tools
+    console.log('[DEPLOY] Deploying hooks for all available tools...');
+    await installer.deployHooks(available);
+
+    console.log('\n[SUCCESS] Deployment completed successfully!');
+    return true;
+  } catch (error) {
+    console.error('[ERROR] Deployment failed:', error.message);
+    return false;
+  }
+}
+
+// Run deployment if called directly
+if (require.main === module) {
+  deploy()
+    .then((success) => {
+      process.exit(success ? 0 : 1);
+    })
+    .catch((error) => {
+      console.error('[FATAL ERROR]:', error.message);
+      process.exit(1);
+    });
+}
+
+module.exports = { deploy };

package/src/index.js

@@ -1,30 +1,30 @@
-#!/usr/bin/env node
-
-/**
- * Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System
- * Unified Entry Point
- * International Version - Pure English & ANSI Only
- * Version: 1.0.94
- */
-
-// Import all components
-const MemoryManager = require('./core/memory_manager');
-const StigmergyInstaller = require('./core/installer');
-const { maxOfTwo, isAuthenticated } = require('./utils/helpers');
-const main = require('./cli/router');
-
-// Run the main application
-if (require.main === module) {
-  main().catch(error => {
-    console.error('[FATAL] Unhandled error in Stigmergy CLI:', error);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  MemoryManager,
-  StigmergyInstaller,
-  maxOfTwo,
-  isAuthenticated,
-  main
-};
+#!/usr/bin/env node
+
+/**
+ * Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System
+ * Unified Entry Point
+ * International Version - Pure English & ANSI Only
+ * Version: 1.0.94
+ */
+
+// Import all components
+const MemoryManager = require('./core/memory_manager');
+const StigmergyInstaller = require('./core/installer');
+const { maxOfTwo, isAuthenticated } = require('./utils/helpers');
+const main = require('./cli/router');
+
+// Run the main application
+if (require.main === module) {
+  main().catch((error) => {
+    console.error('[FATAL] Unhandled error in Stigmergy CLI:', error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  MemoryManager,
+  StigmergyInstaller,
+  maxOfTwo,
+  isAuthenticated,
+  main,
+};

package/src/test/cli-availability-checker.js

@@ -0,0 +1,194 @@
+/**
+ * CLI Availability Checker
+ * Detects which CLI tools are installed and available for testing
+ */
+
+const { spawn } = require('child_process');
+const { CLI_TOOLS } = require('../../src/core/cli_tools');
+
+class CLIAvailabilityChecker {
+  constructor() {
+    this.checkedTools = new Map();
+    this.timeout = 5000; // 5 seconds timeout for each check
+  }
+
+  /**
+   * Check if a CLI tool is installed and available
+   * @param {string} toolName - Name of the CLI tool
+   * @returns {Promise<boolean>} True if tool is available
+   */
+  async isToolAvailable(toolName) {
+    if (this.checkedTools.has(toolName)) {
+      return this.checkedTools.get(toolName);
+    }
+
+    const tool = CLI_TOOLS[toolName];
+    if (!tool) {
+      this.checkedTools.set(toolName, false);
+      return false;
+    }
+
+    try {
+      const isAvailable = await this.checkToolExists(toolName, tool.version);
+      this.checkedTools.set(toolName, isAvailable);
+      return isAvailable;
+    } catch (error) {
+      this.checkedTools.set(toolName, false);
+      return false;
+    }
+  }
+
+  /**
+   * Check if a specific command exists
+   * @param {string} toolName - Tool name
+   * @param {string} versionCommand - Command to check version
+   * @returns {Promise<boolean>} True if command exists
+   */
+  async checkToolExists(toolName, versionCommand) {
+    return new Promise((resolve) => {
+      const parts = versionCommand.split(' ');
+      const command = parts[0];
+      const args = parts.slice(1);
+
+      const child = spawn(command, args, {
+        stdio: 'pipe',
+        shell: true,
+        windowsHide: true
+      });
+
+      let resolved = false;
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      // Set timeout
+      const timeoutId = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          child.kill('SIGTERM');
+          resolve(false);
+        }
+      }, this.timeout);
+
+      child.on('close', (code) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeoutId);
+
+          // Check for serious errors
+          if (stderr.includes('ERR_MODULE_NOT_FOUND') ||
+              stderr.includes('Cannot find module') ||
+              stderr.includes('command not found') ||
+              stderr.includes('is not recognized')) {
+            resolve(false);
+            return;
+          }
+
+          // Consider exit code 0, 1, or 255 as success
+          // Some CLIs return 255 for version commands
+          // But also check that we got some output (not just empty error)
+          const hasOutput = stdout.length > 0 || (stderr.length > 0 && !stderr.includes('Error'));
+          resolve((code === 0 || code === 1 || code === 255) && hasOutput);
+        }
+      });
+
+      child.on('error', () => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeoutId);
+          resolve(false);
+        }
+      });
+    });
+  }
+
+  /**
+   * Get availability of all CLI tools
+   * @returns {Promise<Object>} Map of tool availability
+   */
+  async checkAllTools() {
+    const results = {};
+    const toolNames = Object.keys(CLI_TOOLS);
+
+    // Check tools sequentially to avoid conflicts
+    for (const toolName of toolNames) {
+      results[toolName] = await this.isToolAvailable(toolName);
+    }
+
+    return results;
+  }
+
+  /**
+   * Get only available tools
+   * @returns {Promise<Array>} List of available tool names
+   */
+  async getAvailableTools() {
+    const allTools = await this.checkAllTools();
+    return Object.entries(allTools)
+      .filter(([_, available]) => available)
+      .map(([name, _]) => name);
+  }
+
+  /**
+   * Get installation commands for unavailable tools
+   * @returns {Promise<Object>} Map of tool to installation command
+   */
+  async getInstallationCommands() {
+    const allTools = await this.checkAllTools();
+    const commands = {};
+
+    Object.entries(allTools).forEach(([toolName, available]) => {
+      if (!available && CLI_TOOLS[toolName]) {
+        commands[toolName] = CLI_TOOLS[toolName].install;
+      }
+    });
+
+    return commands;
+  }
+
+  /**
+   * Print availability report
+   */
+  async printAvailabilityReport() {
+    const allTools = await this.checkAllTools();
+    const available = Object.entries(allTools).filter(([_, a]) => a).length;
+    const total = Object.keys(allTools).length;
+
+    console.log('\n=== CLI Tool Availability Report ===');
+    console.log(`Available: ${available}/${total}\n`);
+
+    console.log('�?Available Tools:');
+    Object.entries(allTools)
+      .filter(([_, available]) => available)
+      .forEach(([toolName, _]) => {
+        console.log(`  - ${toolName}`);
+      });
+
+    const unavailable = Object.entries(allTools).filter(([_, a]) => !a);
+    if (unavailable.length > 0) {
+      console.log('\n�?Unavailable Tools:');
+      unavailable.forEach(([toolName, _]) => {
+        console.log(`  - ${toolName}`);
+        console.log(`    Install: ${CLI_TOOLS[toolName].install}`);
+      });
+    }
+
+    console.log('=====================================\n');
+  }
+
+  /**
+   * Clear cache of checked tools
+   */
+  clearCache() {
+    this.checkedTools.clear();
+  }
+}
+
+module.exports = CLIAvailabilityChecker;

package/src/test/test-environment.js

@@ -0,0 +1,289 @@
+/**
+ * Test Environment Isolation
+ * Creates isolated environment for testing without affecting user setup
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+class TestEnvironment {
+  constructor(name = 'stigmergy-test') {
+    this.name = name;
+    this.baseDir = path.join(os.tmpdir(), name);
+    this.originalEnv = { ...process.env };
+    this.isSetup = false;
+  }
+
+  /**
+   * Setup isolated test environment
+   * @param {Object} options - Setup options
+   */
+  async setup(options = {}) {
+    const { clean = true } = options;
+
+    // Create base directory
+    if (clean && fs.existsSync(this.baseDir)) {
+      await this.cleanup();
+    }
+    fs.mkdirSync(this.baseDir, { recursive: true });
+
+    // Setup home directory
+    this.testHome = path.join(this.baseDir, 'home');
+    fs.mkdirSync(this.testHome, { recursive: true });
+
+    // Setup test configuration directories
+    this.configDirs = {
+      stigmergy: path.join(this.testHome, '.stigmergy'),
+      claude: path.join(this.testHome, '.claude'),
+      gemini: path.join(this.testHome, '.gemini'),
+      qwen: path.join(this.testHome, '.qwen'),
+      // Add more as needed
+    };
+
+    Object.values(this.configDirs).forEach(dir => {
+      fs.mkdirSync(dir, { recursive: true });
+    });
+
+    // Modify environment variables
+    process.env.HOME = this.testHome;
+    process.env.USERPROFILE = this.testHome; // Windows
+    process.env.PATH = this.createSafePath();
+
+    this.isSetup = true;
+  }
+
+  /**
+   * Create safe PATH with essential tools only
+   * @returns {string} Safe PATH
+   */
+  createSafePath() {
+    const essentialPaths = [
+      '/usr/bin',
+      '/usr/local/bin',
+      path.join(process.env.ProgramFiles || '', 'Git', 'bin'),
+      path.join(process.env.ProgramFiles || '', 'nodejs'),
+    ].filter(p => p && fs.existsSync(p));
+
+    return essentialPaths.join(path.delimiter);
+  }
+
+  /**
+   * Setup mock CLI tools for testing
+   * @param {Object} mockTools - Map of tool name to mock implementation
+   */
+  async setupMockCLIs(mockTools = {}) {
+    const mockBinDir = path.join(this.testHome, 'bin');
+    fs.mkdirSync(mockBinDir, { recursive: true });
+
+    // Add mock bin directory to PATH
+    process.env.PATH = `${mockBinDir}${path.delimiter}${process.env.PATH}`;
+
+    for (const [toolName, behavior] of Object.entries(mockTools)) {
+      await this.createMockCLI(toolName, behavior, mockBinDir);
+    }
+  }
+
+  /**
+   * Create a mock CLI tool
+   * @param {string} name - Tool name
+   * @param {Object} behavior - Mock behavior
+   * @param {string} binDir - Binary directory
+   */
+  async createMockCLI(name, behavior, binDir) {
+    const script = this.generateMockScript(name, behavior);
+    const scriptPath = path.join(binDir, name);
+
+    if (process.platform === 'win32') {
+      // Windows batch file
+      const batPath = scriptPath + '.cmd';
+      fs.writeFileSync(batPath, `@echo off\n${script}\n`, 'utf8');
+      // Make executable
+      fs.chmodSync(batPath, '755');
+    } else {
+      // Unix shell script
+      fs.writeFileSync(scriptPath, `#!/bin/bash\n${script}\n`, 'utf8');
+      // Make executable
+      fs.chmodSync(scriptPath, '755');
+    }
+  }
+
+  /**
+   * Generate mock script content
+   * @param {string} toolName - Tool name
+   * @param {Object} behavior - Mock behavior definition
+   * @returns {string} Script content
+   */
+  generateMockScript(toolName, behavior) {
+    const defaultBehavior = {
+      version: `${toolName} version 1.0.0-mock`,
+      success: true,
+      delay: 0,
+      output: `Mock ${toolName} executed successfully`
+    };
+
+    const config = { ...defaultBehavior, ...behavior };
+
+    let script = '';
+    if (config.delay > 0) {
+      script += `sleep ${config.delay}\n`;
+    }
+
+    // Handle version command
+    script += `if echo "$*" | grep -q "\\-\\-version\\|-v"; then\n`;
+    script += `  echo "${config.version}"\n`;
+    script += `  exit 0\n`;
+    script += `fi\n`;
+
+    // Handle help command
+    script += `if echo "$*" | grep -q "\\-\\-help\\|-h"; then\n`;
+    script += `  echo "Mock ${toolName} help"\n`;
+    script += `  echo "Usage: ${toolName} [options]"\n`;
+    script += `  exit 0\n`;
+    script += `fi\n`;
+
+    // Handle prompt flag
+    script += `PROMPT=""\n`;
+    script += `for arg in "$@"; do\n`;
+    script += `  if [[ "$arg" == "-p" ]]; then\n`;
+    script += `    PROMPT="$1"\n`;
+    script += `    shift\n`;
+    script += `  fi\n`;
+    script += `  shift\n`;
+    script += `done\n`;
+
+    // Generate response
+    script += `if [ -n "$PROMPT" ]; then\n`;
+    script += `  echo "Mock response for: $PROMPT"\n`;
+    script += `  echo "${config.output}"\n`;
+    script += `else\n`;
+    script += `  echo "${config.output}"\n`;
+    script += `fi\n`;
+
+    // Handle success/failure
+    script += config.success ? 'exit 0\n' : 'exit 1\n';
+
+    return script;
+  }
+
+  /**
+   * Execute command in isolated environment
+   * @param {string} command - Command to execute
+   * @param {Array} args - Command arguments
+   * @param {Object} options - Execution options
+   * @returns {Promise<Object>} Execution result
+   */
+  async execute(command, args = [], options = {}) {
+    if (!this.isSetup) {
+      throw new Error('Test environment not setup. Call setup() first.');
+    }
+
+    return new Promise((resolve) => {
+      let stdout = '';
+      let stderr = '';
+
+      const child = spawn(command, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: true,
+        env: process.env, // Use modified environment
+        ...options
+      });
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        resolve({
+          success: code === 0,
+          stdout,
+          stderr,
+          exitCode: code
+        });
+      });
+
+      child.on('error', (error) => {
+        resolve({
+          success: false,
+          stdout,
+          stderr,
+          error: error.message
+        });
+      });
+    });
+  }
+
+  /**
+   * Create test data in environment
+   * @param {Object} testData - Test data structure
+   */
+  createTestData(testData = {}) {
+    for (const [filePath, content] of Object.entries(testData)) {
+      const fullPath = path.join(this.testHome, filePath);
+      const dir = path.dirname(fullPath);
+
+      // Create directory if it doesn't exist
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      // Write file
+      if (typeof content === 'object') {
+        fs.writeFileSync(fullPath, JSON.stringify(content, null, 2), 'utf8');
+      } else {
+        fs.writeFileSync(fullPath, content, 'utf8');
+      }
+    }
+  }
+
+  /**
+   * Restore original environment
+   */
+  restore() {
+    if (!this.isSetup) return;
+
+    // Restore environment variables
+    Object.keys(this.originalEnv).forEach(key => {
+      process.env[key] = this.originalEnv[key];
+    });
+
+    // Remove any additions
+    const addedKeys = Object.keys(process.env).filter(key => !this.originalEnv.hasOwnProperty(key));
+    addedKeys.forEach(key => {
+      delete process.env[key];
+    });
+
+    this.isSetup = false;
+  }
+
+  /**
+   * Cleanup test environment
+   */
+  async cleanup() {
+    this.restore();
+
+    try {
+      if (fs.existsSync(this.baseDir)) {
+        fs.rmSync(this.baseDir, { recursive: true, force: true });
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not cleanup test directory: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get path in test environment
+   * @param {...string} parts - Path parts
+   * @returns {string} Full path in test environment
+   */
+  getPath(...parts) {
+    return path.join(this.testHome, ...parts);
+  }
+}
+
+module.exports = TestEnvironment;