stigmergy 1.2.10 → 1.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stigmergy",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System",
   "main": "src/index.js",
   "bin": {

package/src/cli/router.js

@@ -45,6 +45,30 @@ function formatBytes(bytes) {
   return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
 }
 
+// Helper function to get appropriate working directory for CLI tools
+function getWorkingDirectoryForTool(toolName) {
+  switch (toolName) {
+    case 'qwen':
+      // For Qwen CLI, use user home directory to avoid module resolution issues
+      return os.homedir();
+    case 'claude':
+      // For Claude CLI, use user home directory
+      return os.homedir();
+    case 'gemini':
+      // For Gemini CLI, use user home directory
+      return os.homedir();
+    case 'iflow':
+      // For iFlow CLI, use user home directory
+      return os.homedir();
+    case 'qodercli':
+      // For Qoder CLI, use user home directory
+      return os.homedir();
+    default:
+      // For other tools, use current directory
+      return process.cwd();
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
 
@@ -757,9 +781,18 @@ async function main() {
             console.log(`[DEBUG] Windows unified command: ${execCommand}`);
           }
           
+          // Set environment for tools that need specific working directories
+          const env = { ...process.env };
+          if (route.tool === 'qwen') {
+            // For Qwen CLI, clear NODE_PATH to avoid import conflicts
+            delete env.NODE_PATH;
+          }
+
           const result = await executeCommand(execCommand, execArgs, {
             stdio: 'inherit',
             shell: true,
+            cwd: getWorkingDirectoryForTool(route.tool),
+            env,
           });
 
           if (!result.success) {
@@ -809,9 +842,17 @@ async function main() {
           // For other execution errors, try to execute the command directly
           // which handles cases where the tool executed successfully but returned an error object
           console.log(`[EXEC] Running: ${toolPath} ${toolArgs.join(' ')}`);
+          // Set environment for tools that need specific working directories
+          const env = { ...process.env };
+          if (route.tool === 'qwen') {
+            delete env.NODE_PATH;
+          }
+
           const result = await executeCommand(toolPath, toolArgs, {
             stdio: 'inherit',
             shell: true,
+            cwd: getWorkingDirectoryForTool(route.tool),
+            env,
           });
 
           if (!result.success) {
@@ -1651,9 +1692,18 @@ async function main() {
             // For other execution errors, try to execute the command directly
             // which handles cases where the tool executed successfully but returned an error object
             console.log(`[EXEC] Running: ${toolPath} ${toolArgs.join(' ')}`);
+
+            // Set environment for tools that need specific working directories
+            const env = { ...process.env };
+            if (route.tool === 'qwen') {
+              delete env.NODE_PATH;
+            }
+
             const result = await executeCommand(toolPath, toolArgs, {
               stdio: 'inherit',
               shell: true,
+              cwd: getWorkingDirectoryForTool(route.tool),
+              env,
             });
             
             if (!result.success) {

package/src/core/cli_path_detector.js

@@ -48,17 +48,52 @@ class CLIPathDetector {
         path.join(process.env.ProgramFiles || 'C:/Program Files', 'npm')
       );
     } else {
-      // Unix-like paths
+      // Unix-like paths - comprehensive coverage
       paths.push(
-        path.join(os.homedir(), '.npm-global', 'bin'), // User local
-        '/usr/local/bin', // System
-        '/usr/bin', // System
-        path.join(os.homedir(), '.npm', 'bin') // User npm
+        // User-specific npm global paths
+        path.join(os.homedir(), '.npm-global', 'bin'), // User local with custom prefix
+        path.join(os.homedir(), '.npm', 'bin'), // User npm
+        path.join(os.homedir(), 'node_modules', '.bin'), // Local node_modules bin
+
+        // System-wide paths
+        '/usr/local/bin', // Common system location
+        '/usr/bin', // System binaries
+        '/opt/node/bin', // Node.js installed to /opt
+        '/opt/nodejs/bin', // Alternative system installation
+
+        // Root-specific paths (when running as root)
+        '/root/.npm-global/bin', // Root user custom prefix
+        '/root/.npm/bin', // Root user npm
+        '/root/node_modules/.bin', // Root local node_modules
+        '/root/.nvm/versions/node/*/bin', // NVM installations for root
+
+        // NVM (Node Version Manager) paths for regular users
+        path.join(os.homedir(), '.nvm', 'versions', 'node', '*', 'bin'), // NVM user installations
+        path.join(os.homedir(), '.nvm', 'current', 'bin'), // NVM current version
+
+        // NodeSource installation paths
+        '/usr/bin/nodejs', // NodeSource package installations
+        '/usr/local/share/npm/bin', // npm share location
+
+        // Homebrew (macOS) paths
+        path.join(os.homedir(), '.brew', 'node', 'bin'), // Custom Homebrew
+        '/opt/homebrew/bin', // Apple Silicon Homebrew
+        '/usr/local/bin', // Intel Homebrew
+
+        // pkg-config and other package managers
+        path.join(os.homedir(), '.local', 'bin'), // User local binaries
+        '/snap/bin', // Snap packages (Ubuntu)
+        '/var/lib/snapd/snap/bin' // Snap system
       );
     }
 
+    // Filter paths, handling wildcards for NVM
     return paths.filter(p => {
       try {
+        // Handle wildcard paths (NVM versions)
+        if (p.includes('*')) {
+          return this.expandWildcardPath(p);
+        }
         return fs.existsSync(p);
       } catch {
         return false;
@@ -66,6 +101,36 @@ class CLIPathDetector {
     });
   }
 
+  /**
+   * Expand wildcard paths (e.g., NVM version paths)
+   */
+  expandWildcardPath(wildcardPath) {
+    try {
+      const { spawnSync } = require('child_process');
+
+      // Use shell to expand wildcards
+      const result = spawnSync('bash', ['-c', `ls -d ${wildcardPath} 2>/dev/null`], {
+        encoding: 'utf8',
+        shell: true
+      });
+
+      if (result.status === 0 && result.stdout.trim()) {
+        // Check if any of the expanded paths exist
+        const expandedPaths = result.stdout.trim().split('\n');
+        return expandedPaths.some(p => {
+          try {
+            return fs.existsSync(p.trim());
+          } catch {
+            return false;
+          }
+        });
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Get current PATH environment variable
    */
@@ -146,8 +211,15 @@ class CLIPathDetector {
     const commandNames = this.cliNameMap[toolName] || [toolName];
 
     for (const command of commandNames) {
+      // Method 0: Use npm to get actual global installation path
+      let pathFound = await this.findCommandViaNPM(command);
+      if (pathFound) {
+        console.log(`[DETECTOR] Found ${toolName} via npm: ${pathFound}`);
+        return pathFound;
+      }
+
       // Method 1: Check system PATH (most common)
-      let pathFound = this.findCommandInPath(command);
+      pathFound = this.findCommandInPath(command);
       if (pathFound) {
         console.log(`[DETECTOR] Found ${toolName} in PATH: ${pathFound}`);
         return pathFound;
@@ -169,11 +241,23 @@ class CLIPathDetector {
           return pathFound;
         }
       } else {
-        const userNPMPath = path.join(os.homedir(), '.npm-global', 'bin');
-        pathFound = this.checkCommandInDir(command, userNPMPath);
-        if (pathFound) {
-          console.log(`[DETECTOR] Found ${toolName} in user npm-global: ${pathFound}`);
-          return pathFound;
+        // Check multiple Unix-like locations
+        const unixPaths = [
+          path.join(os.homedir(), '.npm-global', 'bin'),
+          path.join(os.homedir(), '.npm', 'bin'),
+          '/usr/local/bin',
+          '/usr/bin',
+          path.join(os.homedir(), '.local', 'bin'),
+          '/root/.npm-global/bin',
+          '/root/.npm/bin'
+        ];
+
+        for (const dir of unixPaths) {
+          pathFound = this.checkCommandInDir(command, dir);
+          if (pathFound) {
+            console.log(`[DETECTOR] Found ${toolName} in ${dir}: ${pathFound}`);
+            return pathFound;
+          }
         }
       }
     }
@@ -182,6 +266,59 @@ class CLIPathDetector {
     return null;
   }
 
+  /**
+   * Find command using npm's actual global installation path
+   */
+  async findCommandViaNPM(command) {
+    try {
+      const { spawnSync } = require('child_process');
+
+      // Get npm global prefix
+      const npmPrefixResult = spawnSync('npm', ['config', 'get', 'prefix'], {
+        encoding: 'utf8',
+        shell: true
+      });
+
+      if (npmPrefixResult.status === 0 && npmPrefixResult.stdout.trim()) {
+        const npmPrefix = npmPrefixResult.stdout.trim();
+        let binDir;
+
+        if (this.platform === 'win32') {
+          binDir = npmPrefix; // Windows: prefix already points to the directory with executables
+        } else {
+          binDir = path.join(npmPrefix, 'bin'); // Unix: bin subdirectory
+        }
+
+        const commandPath = this.checkCommandInDir(command, binDir);
+        if (commandPath) {
+          return commandPath;
+        }
+      }
+
+      // Try alternative npm config methods
+      const npmListResult = spawnSync('npm', ['list', '-g', '--depth=0'], {
+        encoding: 'utf8',
+        shell: true
+      });
+
+      if (npmListResult.status === 0) {
+        // Extract global prefix from npm list output if needed
+        const lines = npmListResult.stdout.split('\n');
+        for (const line of lines) {
+          if (line.includes(`${command}@`)) {
+            // Package is installed globally, try to find it in common locations
+            return null; // Fall back to other methods
+          }
+        }
+      }
+
+      return null;
+    } catch (error) {
+      console.log(`[DETECTOR] npm query failed: ${error.message}`);
+      return null;
+    }
+  }
+
   /**
    * Detect all CLI tool paths
    */