stigmergy 1.3.9 → 1.3.11

package/package.json

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

package/src/utils.js

@@ -701,25 +701,51 @@ async function executeCommand(command, args = [], options = {}) {
 
       let timeoutId = null;
 
-      child.on('close', (code) => {
-        // Clear timeout if it exists
-        if (timeoutId) {
+      // Flag to ensure timeout is cleared only once
+      let timeoutCleared = false;
+
+      // Function to clear timeout safely
+      const clearTimeoutSafely = () => {
+        if (timeoutId && !timeoutCleared) {
           clearTimeout(timeoutId);
+          timeoutCleared = true;
         }
+      };
+
+      child.on('exit', (code, signal) => {
+        // Clear timeout when process exits
+        clearTimeoutSafely();
 
+        // Resolve with collected stdout/stderr
         resolve({
           code,
+          signal,
           stdout,
           stderr,
           success: code === 0,
         });
       });
 
-      child.on('error', (error) => {
-        // Clear timeout if it exists
-        if (timeoutId) {
-          clearTimeout(timeoutId);
+      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 (!timeoutCleared) {
+          resolve({
+            code,
+            signal,
+            stdout,
+            stderr,
+            success: code === 0,
+          });
         }
+      });
+
+      child.on('error', (error) => {
+        // Clear timeout on error
+        clearTimeoutSafely();
 
         // Provide more detailed error information
         let errorMessage = error.message;

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