stigmergy 1.3.10 → 1.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stigmergy",
-  "version": "1.3.10",
+  "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,25 +717,51 @@ async function executeCommand(command, args = [], options = {}) {
         }
       };
 
-      child.on('exit', (code) => {
+      // 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,
           stderr,
           success: code === 0,
         });
       });
 
-      child.on('close', (code) => {
+      child.on('close', (code, signal) => {
         // Clear timeout when all stdio streams are closed
         clearTimeoutSafely();
 
         // Only resolve if not already resolved via 'exit' event
         // This prevents duplicate resolution
+        if (!promiseResolved) {
+          safeResolve({
+            code,
+            signal,
+            stdout,
+            stderr,
+            success: code === 0,
+          });
+        }
       });
 
       child.on('error', (error) => {
@@ -756,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({

package/test/simple_test.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test for basic functionality
+ */
+
+// Mock the CLI tools to ensure they're available for testing
+jest.doMock('../src/core/cli_tools', () => ({
+  CLI_TOOLS: {
+    claude: { name: 'Claude CLI', command: 'claude', version: 'claude --version' },
+    qwen: { name: 'Qwen CLI', command: 'qwen', version: 'qwen --version' },
+    gemini: { name: 'Gemini CLI', command: 'gemini', version: 'gemini --version' },
+    iflow: { name: 'iFlow CLI', command: 'iflow', version: 'iflow --version' },
+    codebuddy: { name: 'CodeBuddy CLI', command: 'codebuddy', version: 'codebuddy --version' },
+    codex: { name: 'Codex CLI', command: 'codex', version: 'codex --version' },
+    qodercli: { name: 'QoderCLI', command: 'qodercli', version: 'qodercli --version' },
+    copilot: { name: 'Copilot CLI', command: 'copilot', version: 'copilot --version' },
+    kode: { name: 'Kode CLI', command: 'kode', version: 'kode --version' }
+  },
+  validateCLITool: jest.fn().mockReturnValue(true)
+}));
+
+// Mock CLIHelpAnalyzer to avoid actual CLI analysis during testing
+jest.doMock('../src/core/cli_help_analyzer', () => {
+  return jest.fn().mockImplementation(() => {
+    return {
+      setCLITools: jest.fn(),
+      initialize: jest.fn().mockResolvedValue(undefined),
+      analyzeCLI: jest.fn().mockResolvedValue({
+        success: true,
+        cliName: 'test-cli',
+        patterns: {
+          commands: [{ name: 'analyze' }, { name: 'generate' }, { name: 'explain' }],
+          subcommands: []
+        }
+      }),
+      loadPersistentConfig: jest.fn().mockResolvedValue({
+        failedAttempts: {},
+        cliPatterns: {}
+      }),
+      getCachedAnalysis: jest.fn().mockResolvedValue(null),
+      isCacheExpired: jest.fn().mockReturnValue(false),
+      generateOptimizedCall: jest.fn().mockReturnValue({
+        optimizedPrompt: 'test prompt'
+      }),
+      getAgentSkillCompatibilityScore: jest.fn().mockReturnValue({ score: 0.5, reasons: ['test'] }),
+      getEnhancedCLIPattern: jest.fn().mockResolvedValue({})
+    };
+  });
+});
+
+const SmartRouter = require('../src/core/smart_router');
+
+async function runSimpleTest() {
+  console.log('Running simple test...');
+  
+  try {
+    const router = new SmartRouter();
+    await router.initialize();
+    
+    console.log('✓ Router initialized successfully');
+    
+    // Test a simple routing case
+    const result = await router.smartRoute('use claude to analyze code');
+    console.log(`✓ Simple routing test passed: ${result.tool}`);
+    
+    // Test shouldRoute functionality
+    const shouldRoute = router.shouldRoute('help with code');
+    console.log(`✓ shouldRoute test passed: ${shouldRoute}`);
+    
+    console.log('All simple tests passed!');
+    return true;
+  } catch (error) {
+    console.error('Simple test failed:', error);
+    return false;
+  }
+}
+
+// Run the test
+runSimpleTest().then(success => {
+  process.exit(success ? 0 : 1);
+});

package/test/very_simple_test.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+/**
+ * Very simple test without complex mocking
+ */
+
+// Simple test to check basic functionality
+async function runVerySimpleTest() {
+  console.log('Running very simple test...');
+  
+  try {
+    // Test basic Node.js functionality
+    console.log('✓ Node.js environment is working');
+    
+    // Test basic string operations
+    const testString = 'hello world';
+    if (testString.toUpperCase() === 'HELLO WORLD') {
+      console.log('✓ String operations working');
+    } else {
+      console.log('✗ String operations failed');
+      return false;
+    }
+    
+    // Test basic math
+    if (2 + 2 === 4) {
+      console.log('✓ Math operations working');
+    } else {
+      console.log('✗ Math operations failed');
+      return false;
+    }
+    
+    // Test basic array operations
+    const arr = [1, 2, 3];
+    arr.push(4);
+    if (arr.length === 4 && arr[3] === 4) {
+      console.log('✓ Array operations working');
+    } else {
+      console.log('✗ Array operations failed');
+      return false;
+    }
+    
+    console.log('All very simple tests passed!');
+    return true;
+  } catch (error) {
+    console.error('Very simple test failed:', error);
+    return false;
+  }
+}
+
+// Run the test
+runVerySimpleTest().then(success => {
+  console.log(`Test completed with success: ${success}`);
+  process.exit(success ? 0 : 1);
+});