stigmergy 1.3.8 → 1.3.9

package/package.json

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

package/src/utils.js

@@ -699,7 +699,14 @@ async function executeCommand(command, args = [], options = {}) {
         });
       }
 
+      let timeoutId = null;
+
       child.on('close', (code) => {
+        // Clear timeout if it exists
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+
         resolve({
           code,
           stdout,
@@ -709,6 +716,11 @@ async function executeCommand(command, args = [], options = {}) {
       });
 
       child.on('error', (error) => {
+        // Clear timeout if it exists
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+
         // Provide more detailed error information
         let errorMessage = error.message;
         if (error.code === 'ENOENT') {
@@ -729,7 +741,7 @@ async function executeCommand(command, args = [], options = {}) {
 
       // Handle timeout
       if (opts.timeout) {
-        setTimeout(() => {
+        timeoutId = setTimeout(() => {
           child.kill();
           reject({
             error: new Error('Command timeout'),

package/test/smart_routing_edge_cases.test.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+
+/**
+ * Edge Cases and Error Handling Tests: Smart Routing
+ * Tests edge cases and error handling scenarios for the SmartRouter class
+ */
+
+const SmartRouter = require('../src/core/smart_router');
+
+// Mock CLI_TOOLS to avoid actual CLI detection during testing
+jest.mock('../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
+jest.mock('../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: [],
+          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({})
+    };
+  });
+});
+
+describe('Smart Routing Edge Cases and Error Handling', () => {
+  let router;
+
+  beforeEach(async () => {
+    router = new SmartRouter();
+    await router.initialize();
+  });
+
+  test('should handle invalid input types gracefully', async () => {
+    // Test with numbers
+    let result = await router.smartRoute(123);
+    expect(result.tool).toBe('claude'); // Should default to default tool
+    expect(result.prompt).toBe('123');
+
+    // Test with objects
+    result = await router.smartRoute({ message: 'test' });
+    expect(result.tool).toBe('claude');
+    expect(result.prompt).toBe('[object Object]');
+
+    // Test with arrays
+    result = await router.smartRoute(['test', 'array']);
+    expect(result.tool).toBe('claude');
+    expect(result.prompt).toBe('test,array');
+  });
+
+  test('should handle very long input strings', async () => {
+    const longInput = 'a'.repeat(10000) + ' use claude to analyze this';
+    const result = await router.smartRoute(longInput);
+    expect(result.tool).toBe('claude');
+    // The prompt should contain the meaningful part of the input
+    expect(result.prompt).toContain('analyze this');
+  });
+
+  test('should handle input with special characters and unicode', async () => {
+    const specialInput = '使用claude分析这段包含特殊字符的代码: !@#$%^&*()中文测试';
+    const result = await router.smartRoute(specialInput);
+    expect(result.tool).toBe('claude');
+    expect(result.prompt).toBe('分析这段包含特殊字符的代码: !@#$%^&*()中文测试');
+  });
+
+  test('should handle multiple tool mentions and choose appropriately', async () => {
+    const input = 'use claude and qwen and gemini to analyze this code';
+    const result = await router.smartRoute(input);
+    // Should pick the first matching tool
+    expect(['claude', 'qwen', 'gemini']).toContain(result.tool);
+    expect(result.prompt).toBeDefined();
+  });
+
+  test('should handle conflicting routing patterns', async () => {
+    const input = 'please use claude to write code with qwen';
+    const result = await router.smartRoute(input);
+    // Should handle the primary routing intent
+    expect(['claude', 'qwen']).toContain(result.tool);
+    expect(result.prompt).toBeDefined();
+  });
+
+  test('should handle non-existent tools gracefully', async () => {
+    // Test with a tool that doesn't exist in the system
+    const input = 'use non-existent-tool to do something';
+    const result = await router.smartRoute(input);
+    // Should default to default tool
+    expect(result.tool).toBe('claude');
+    expect(result.prompt).toBe('use non-existent-tool to do something');
+  });
+
+  test('should handle tools with similar names correctly', async () => {
+    // Test tools that might have similar names or keywords
+    const input = 'use codex and codebuddy to help with code';
+    const result = await router.smartRoute(input);
+    // Should match the first appropriate tool
+    expect(['codex', 'codebuddy']).toContain(result.tool);
+  });
+
+  test('should handle routing when CLI analysis fails', async () => {
+    // Mock a failure in CLI analysis
+    const originalGetOptimizedCLIPattern = router.getOptimizedCLIPattern;
+    router.getOptimizedCLIPattern = jest.fn().mockRejectedValue(new Error('CLI analysis failed'));
+    
+    try {
+      const result = await router.smartRoute('analyze this code with claude');
+      // Should still return a valid result even if CLI analysis fails
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('analyze this code with claude');
+    } finally {
+      // Restore original method
+      router.getOptimizedCLIPattern = originalGetOptimizedCLIPattern;
+    }
+  });
+
+  test('should handle routing when validation fails', async () => {
+    // Mock a validation failure
+    const originalValidateCLITool = require('../src/core/cli_tools').validateCLITool;
+    require('../src/core/cli_tools').validateCLITool.mockReturnValue(false);
+    
+    try {
+      const result = await router.smartRoute('use claude to analyze');
+      // Should still work with default fallback
+      expect(result.tool).toBe('claude');
+    } finally {
+      // Restore original validation
+      require('../src/core/cli_tools').validateCLITool.mockReturnValue(true);
+    }
+  });
+
+  test('should handle enhanced routing when compatibility scoring fails', async () => {
+    const originalGetAgentSkillCompatibilityScore = router.getAgentSkillCompatibilityScore;
+    
+    // Mock a failure in compatibility scoring
+    router.getAgentSkillCompatibilityScore = jest.fn().mockRejectedValue(new Error('Scoring failed'));
+    
+    try {
+      const result = await router.smartRouteEnhanced('use claude to analyze');
+      // Should still return a result with fallback scoring
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('use claude to analyze');
+      expect(result.confidence).toBeDefined();
+    } finally {
+      // Restore original method
+      router.getAgentSkillCompatibilityScore = originalGetAgentSkillCompatibilityScore;
+    }
+  });
+
+  test('should handle fallback routing generation properly', async () => {
+    // Test the fallback generation method directly
+    const primaryRoute = { tool: 'claude', prompt: 'analyze this code' };
+    const error = new Error('Primary route failed');
+    
+    const fallbacks = await router.generateFallbackRoutes(primaryRoute, error);
+    
+    // Should return an array of fallback routes
+    expect(Array.isArray(fallbacks)).toBe(true);
+    
+    // Each fallback should have the required properties
+    for (const fallback of fallbacks) {
+      expect(fallback.tool).toBeDefined();
+      expect(fallback.prompt).toBe(primaryRoute.prompt);
+      expect(fallback.confidence).toBeDefined();
+      expect(fallback.compatibility).toBeDefined();
+    }
+  });
+
+  test('should handle execution with multiple retries', async () => {
+    // Test the executeEnhancedRoute method with retry logic
+    // This is a complex test that verifies the retry mechanism works
+    const originalSmartRouteEnhanced = router.smartRouteEnhanced;
+    
+    // Mock the method to fail the first time and succeed the second time
+    let callCount = 0;
+    router.smartRouteEnhanced = jest.fn().mockImplementation((input) => {
+      callCount++;
+      if (callCount === 1) {
+        throw new Error('First attempt failed');
+      }
+      return originalSmartRouteEnhanced.call(router, input);
+    });
+    
+    try {
+      const result = await router.executeEnhancedRoute('use claude to analyze');
+      // Should succeed after retry
+      expect(result.tool).toBe('claude');
+    } finally {
+      // Restore original method
+      router.smartRouteEnhanced = originalSmartRouteEnhanced;
+    }
+  });
+
+  test('should handle cache expiration properly', async () => {
+    // Test the isRecentFailure method with various timestamps
+    const now = new Date();
+    const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000); // Exactly 1 hour ago
+    const fiftyNineMinsAgo = new Date(now.getTime() - 59 * 60 * 1000); // 59 minutes ago
+    const twoHoursAgo = new Date(now.getTime() - 2 * 60 * 60 * 1000); // 2 hours ago
+    
+    // 59 minutes ago should be considered recent (less than 1 hour)
+    expect(router.isRecentFailure(fiftyNineMinsAgo.toISOString())).toBe(true);
+    
+    // 1 hour ago should not be considered recent (equal to 1 hour)
+    expect(router.isRecentFailure(oneHourAgo.toISOString())).toBe(false);
+    
+    // 2 hours ago should not be considered recent
+    expect(router.isRecentFailure(twoHoursAgo.toISOString())).toBe(false);
+  });
+
+  test('should handle unusual input patterns', async () => {
+    const unusualInputs = [
+      'CLAUDE analyze this', // Uppercase
+      '   use   claude   to   analyze   ', // Extra spaces
+      'use\nclaude\nto\nanalyze', // Newlines
+      'use\tclaude\tto\tanalyze', // Tabs
+      'use  claude  to  analyze', // Multiple spaces
+      'claude\'s analysis needed', // Possessive form
+      'about claude and his analysis', // Reference to tool
+    ];
+    
+    for (const input of unusualInputs) {
+      const result = await router.smartRoute(input);
+      // Should handle all these inputs gracefully
+      expect(result.tool).toBeDefined();
+      expect(result.prompt).toBeDefined();
+    }
+  });
+
+  test('should handle empty or invalid CLI patterns', async () => {
+    const originalGetOptimizedCLIPattern = router.getOptimizedCLIPattern;
+    
+    // Mock to return null/empty patterns
+    router.getOptimizedCLIPattern = jest.fn().mockResolvedValue(null);
+    
+    try {
+      const result = await router.smartRoute('use claude to analyze');
+      // Should still work even with null CLI pattern
+      expect(result.tool).toBe('claude');
+    } finally {
+      // Restore original method
+      router.getOptimizedCLIPattern = originalGetOptimizedCLIPattern;
+    }
+  });
+
+  test('should handle complex nested routing scenarios', async () => {
+    // Test complex scenario with multiple potential matches
+    const complexInput = 'Please use Claude (the best AI) to analyze this code, but if Claude is not available, try Qwen or Gemini';
+    const result = await router.smartRoute(complexInput);
+    
+    // Should identify the primary intent (Claude)
+    expect(['claude', 'qwen', 'gemini']).toContain(result.tool);
+    expect(result.prompt).toBeDefined();
+  });
+});
+
+console.log('Smart Routing Edge Cases and Error Handling Tests - All tests defined and ready to run');