stigmergy 1.3.11 → 1.3.13

package/package.json

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

package/src/cli/commands/project.js

@@ -336,26 +336,41 @@ async function executeSmartRoutedCommand(route, options = {}) {
 
     // Use enhanced parameter handling for one-time mode only
     if (mode === 'one-time') {
-      const EnhancedCLIParameterHandler = require('../../core/enhanced_cli_parameter_handler');
-      const paramHandler = new EnhancedCLIParameterHandler();
-
-      // Generate optimized arguments with agent/skill support
-      const paramResult = await paramHandler.generateArgumentsWithRetry(
-        route.tool,
-        route.prompt,
-        {
-          maxRetries,
-          enableAgentSkillOptimization: true
+      try {
+        const EnhancedCLIParameterHandler = require('../../core/enhanced_cli_parameter_handler');
+        const paramHandler = new EnhancedCLIParameterHandler();
+
+        // Generate optimized arguments with agent/skill support
+        // Add timeout protection for parameter generation
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => reject(new Error('Parameter generation timeout')), 30000); // 30 second timeout for parameter generation
+        });
+
+        const paramPromise = paramHandler.generateArgumentsWithRetry(
+          route.tool,
+          route.prompt,
+          {
+            maxRetries,
+            enableAgentSkillOptimization: true
+          }
+        );
+
+        const paramResult = await Promise.race([paramPromise, timeoutPromise]);
+
+        toolArgs = paramResult.arguments;
+
+        // Re-add OAuth authentication (paramResult might overwrite)
+        toolArgs = addOAuthAuthArgs(route.tool, toolArgs);
+
+        if (verbose) {
+          console.log(chalk.gray(`[DEBUG] Generated args: ${toolArgs.join(' ')}`));
+        }
+      } catch (paramError) {
+        console.log(chalk.yellow(`[WARN] Parameter generation failed: ${paramError.message}, using basic arguments`));
+        // Fallback to basic arguments if enhanced parameter generation fails
+        if (verbose) {
+          console.log(chalk.gray(`[DEBUG] Falling back to basic args: ${toolArgs.join(' ')}`));
         }
-      );
-
-      toolArgs = paramResult.arguments;
-
-      // Re-add OAuth authentication (paramResult might overwrite)
-      toolArgs = addOAuthAuthArgs(route.tool, toolArgs);
-
-      if (verbose) {
-        console.log(chalk.gray(`[DEBUG] Generated args: ${toolArgs.join(' ')}`));
       }
     } else {
       if (verbose) {
@@ -379,15 +394,23 @@ async function executeSmartRoutedCommand(route, options = {}) {
       console.log(chalk.gray(`[DEBUG] Mode: ${mode}`));
     }
 
+    console.log(chalk.gray(`[EXEC] ${route.tool}: ${route.prompt}`)); // Add this to match direct command format
+
     // Execute the command
     // For interactive mode, we need stdio: 'inherit' to allow user interaction
+    // For one-time mode, we should use 'inherit' to ensure CLI tools can properly execute
+    const stdioOption = mode === 'interactive' ? 'inherit' : 'inherit'; // Use 'inherit' for both modes to ensure proper CLI execution
+
+    console.log(chalk.gray(`[DEBUG] About to execute command with args: ${toolArgs.join(' ')}`)); // Debug log
+    console.log(chalk.gray(`[DEBUG] Using stdio option: ${stdioOption}`)); // Debug log
     const result = await executeCommand(toolPath, toolArgs, {
-      stdio: mode === 'interactive' ? 'inherit' : 'pipe',
+      stdio: stdioOption,
       shell: true,
       cwd,
       env,
       timeout: 300000 // 5 minutes
     });
+    console.log(chalk.gray(`[DEBUG] Command execution completed`)); // Debug log
 
     return { success: true, tool: route.tool, result, mode };
 

package/src/utils.js

@@ -631,10 +631,12 @@ async function executeCommand(command, args = [], options = {}) {
   const opts = {
     stdio: 'inherit',
     shell: true,
-    timeout: 300000, // 5 minute timeout
     ...options,
   };
 
+  // Extract timeout from options to handle separately
+  const timeoutValue = options.timeout || 300000; // Default to 5 minutes if not specified
+
   return new Promise((resolve, reject) => {
     // Don't log the command if it contains sensitive information
     if (process.env.DEBUG === 'true') {
@@ -704,6 +706,9 @@ async function executeCommand(command, args = [], options = {}) {
       // Flag to ensure timeout is cleared only once
       let timeoutCleared = false;
 
+      // Flag to prevent duplicate promise resolution
+      let promiseResolved = false;
+
       // Function to clear timeout safely
       const clearTimeoutSafely = () => {
         if (timeoutId && !timeoutCleared) {
@@ -712,12 +717,28 @@ async function executeCommand(command, args = [], options = {}) {
         }
       };
 
+      // Function to resolve safely (prevent duplicate resolution)
+      const safeResolve = (result) => {
+        if (!promiseResolved) {
+          promiseResolved = true;
+          resolve(result);
+        }
+      };
+
+      // Function to reject safely (prevent duplicate rejection)
+      const safeReject = (error) => {
+        if (!promiseResolved) {
+          promiseResolved = true;
+          reject(error);
+        }
+      };
+
       child.on('exit', (code, signal) => {
         // Clear timeout when process exits
         clearTimeoutSafely();
 
         // Resolve with collected stdout/stderr
-        resolve({
+        safeResolve({
           code,
           signal,
           stdout,
@@ -732,8 +753,8 @@ async function executeCommand(command, args = [], options = {}) {
 
         // Only resolve if not already resolved via 'exit' event
         // This prevents duplicate resolution
-        if (!timeoutCleared) {
-          resolve({
+        if (!promiseResolved) {
+          safeResolve({
             code,
             signal,
             stdout,
@@ -766,16 +787,16 @@ async function executeCommand(command, args = [], options = {}) {
       });
 
       // Handle timeout
-      if (opts.timeout) {
+      if (timeoutValue) {
         timeoutId = setTimeout(() => {
           child.kill();
           reject({
             error: new Error('Command timeout'),
-            message: `Command timed out after ${opts.timeout}ms`,
+            message: `Command timed out after ${timeoutValue}ms`,
             stdout,
             stderr,
           });
-        }, opts.timeout);
+        }, timeoutValue);
       }
     } catch (error) {
       reject({