stigmergy 1.2.13 → 1.3.2-beta.0

package/src/core/multilingual/language-pattern-manager.js

@@ -179,7 +179,7 @@ class LanguagePatternManager {
         
         // Validate that the target CLI is supported
         const supportedCLIs = [
-          'claude', 'gemini', 'qwen', 'iflow', 'qodercli', 'codebuddy', 'codex', 'copilot'
+          'claude', 'gemini', 'qwen', 'iflow', 'qodercli', 'codebuddy', 'codex', 'copilot', 'kode'
         ];
         
         if (supportedCLIs.includes(targetCLI)) {

package/src/core/skills/StigmergySkillManager.js

@@ -121,22 +121,40 @@ export class StigmergySkillManager {
 
     /**
      * Sync skills to CLI configuration files
+     * Also refreshes the LocalSkillScanner cache
      * @returns {Promise<void>}
      */
     async sync() {
         console.log('[INFO] Syncing skills to CLI configuration files...');
-        
+
         try {
+            // Refresh the LocalSkillScanner cache
+            try {
+                // Import LocalSkillScanner (it's a CommonJS module)
+                const { createRequire } = await import('module');
+                const require = createRequire(import.meta.url);
+                const LocalSkillScanner = require('./local_skill_scanner.js');
+
+                const scanner = new LocalSkillScanner();
+                await scanner.initialize(true); // Force refresh
+                console.log('[INFO] Refreshed skills/agents cache');
+            } catch (err) {
+                // LocalSkillScanner might not be available, ignore
+                if (process.env.DEBUG === 'true') {
+                    console.log('[DEBUG] LocalSkillScanner not available:', err.message);
+                }
+            }
+
             const skills = await this.reader.listSkills();
-            
+
             if (skills.length === 0) {
                 console.log('[INFO] No skills to sync');
                 return;
             }
-            
+
             // Generate <available_skills> XML
             const skillsXml = this.generateSkillsXml(skills);
-            
+
             // All CLI configuration files to update
             const cliFiles = [
                 'AGENTS.md',      // Universal config
@@ -149,15 +167,15 @@ export class StigmergySkillManager {
                 'copilot.md',     // Copilot CLI
                 'codex.md'        // Codex CLI
             ];
-            
+
             let syncedCount = 0;
             let createdCount = 0;
             let skippedCount = 0;
-            
+
             // Iterate through all CLI configuration files
             for (const fileName of cliFiles) {
                 const filePath = path.join(process.cwd(), fileName);
-                
+
                 try {
                     const result = await this.syncToFile(filePath, fileName, skillsXml);
                     if (result === 'synced') {
@@ -170,7 +188,7 @@ export class StigmergySkillManager {
                     skippedCount++;
                 }
             }
-            
+
             // Output sync result summary
             console.log(`\n[OK] Sync completed:`);
             console.log(`   - Updated: ${syncedCount} file(s)`);

package/src/core/smart_router.js

@@ -2,9 +2,23 @@ const CLIHelpAnalyzer = require('./cli_help_analyzer');
 const { CLI_TOOLS, validateCLITool } = require('./cli_tools');
 const { errorHandler } = require('./error_handler');
 
+// Valid CLI tools whitelist - excludes helper functions attached to CLI_TOOLS
+const VALID_CLI_TOOLS = [
+  'claude',
+  'gemini',
+  'qwen',
+  'iflow',
+  'codebuddy',
+  'codex',
+  'qodercli',
+  'copilot',
+  'kode'
+];
+
 class SmartRouter {
   constructor() {
     this.tools = CLI_TOOLS;
+    this.validTools = VALID_CLI_TOOLS;
     try {
       this.analyzer = new CLIHelpAnalyzer();
       this.analyzer.setCLITools(this.tools);
@@ -66,7 +80,8 @@ class SmartRouter {
     const inputLower = input.toLowerCase();
 
     // First, check for exact tool name matches (higher priority)
-    for (const [toolName, _] of Object.entries(this.tools)) {
+    // Only iterate through valid CLI tools (exclude helper functions)
+    for (const toolName of this.validTools) {
       try {
         // Validate tool configuration
         validateCLITool(toolName);
@@ -99,7 +114,7 @@ class SmartRouter {
     // Then check for keyword matches (lower priority)
     // Only analyze tools that are likely to match to reduce overhead
     const potentialMatches = [];
-    for (const [toolName, _] of Object.entries(this.tools)) {
+    for (const toolName of this.validTools) {
       // Quick check: if the input is very short, only analyze a few key tools
       if (input.length < 20) {
         // For short inputs, only analyze commonly used tools
@@ -230,6 +245,7 @@ class SmartRouter {
       codebuddy: ['codebuddy', 'buddy', 'assistant'],
       copilot: ['copilot', 'github', 'gh'],
       codex: ['codex', 'openai', 'gpt'], // Remove 'code' from here to avoid conflicts
+      kode: ['kode', 'multi-model', 'collaboration', 'multi模型']
     };
 
     if (toolSpecificKeywords[toolName]) {
@@ -256,6 +272,267 @@ class SmartRouter {
 
     return [...new Set(keywords)]; // Remove duplicates
   }
+
+  /**
+   * Enhanced smart routing with agent and skill support
+   */
+  async smartRouteEnhanced(userInput, options = {}) {
+    const input = userInput.trim();
+    const inputLower = input.toLowerCase();
+    
+    // Enhanced routing priorities based on agent/skill detection
+    const routingResults = [];
+
+    // Analyze all valid CLI tools for agent/skill compatibility
+    for (const toolName of this.validTools) {
+      try {
+        validateCLITool(toolName);
+
+        // Get compatibility score for this tool
+        const compatibility = await this.getAgentSkillCompatibilityScore(toolName, input);
+
+        // Check for exact tool name matches (highest priority)
+        let matchScore = 0;
+        if (inputLower.includes(toolName)) {
+          matchScore = 1.0;
+        } else if (compatibility.score > 0) {
+          matchScore = compatibility.score;
+        }
+
+        if (matchScore > 0) {
+          // Get enhanced CLI pattern
+          const enhancedPattern = await this.getEnhancedCLIPattern(toolName);
+
+          // Generate optimized command
+          const optimizedCall = this.analyzer.generateOptimizedCall(toolName, input);
+
+          routingResults.push({
+            tool: toolName,
+            score: matchScore,
+            compatibility,
+            pattern: enhancedPattern,
+            optimizedCall,
+            reasons: this.getRoutingReasons(toolName, input, compatibility)
+          });
+        }
+      } catch (error) {
+        // Skip tools with configuration errors
+        continue;
+      }
+    }
+
+    // Sort by score (descending)
+    routingResults.sort((a, b) => b.score - a.score);
+
+    // Return best match or default
+    if (routingResults.length > 0) {
+      const bestMatch = routingResults[0];
+      return {
+        tool: bestMatch.tool,
+        prompt: bestMatch.optimizedCall?.optimizedPrompt || input,
+        confidence: bestMatch.score,
+        compatibility: bestMatch.compatibility,
+        optimizedCall: bestMatch.optimizedCall,
+        routingReasons: bestMatch.reasons,
+        alternativeOptions: routingResults.slice(1, 3) // Top 2 alternatives
+      };
+    }
+
+    // Default routing with enhanced pattern
+    const cleanInput = input
+      .replace(/^(use|please|help|using|with)\s*/i, '')
+      .trim();
+    
+    return {
+      tool: this.defaultTool,
+      prompt: cleanInput,
+      confidence: 0.3,
+      compatibility: await this.getAgentSkillCompatibilityScore(this.defaultTool, input),
+      routingReasons: ['默认路由'],
+      alternativeOptions: []
+    };
+  }
+
+  /**
+   * Get agent/skill compatibility score for CLI tool
+   */
+  async getAgentSkillCompatibilityScore(toolName, prompt) {
+    try {
+      if (this.analyzer && this.analyzer.getAgentSkillCompatibilityScore) {
+        return this.analyzer.getAgentSkillCompatibilityScore(toolName, prompt);
+      }
+    } catch (error) {
+      if (process.env.DEBUG === 'true') {
+        console.log(`Error getting compatibility score for ${toolName}:`, error.message);
+      }
+    }
+    
+    // Fallback scoring
+    return { score: 0.5, reasons: ['基础兼容性'] };
+  }
+
+  /**
+   * Get enhanced CLI pattern with agent/skill support
+   */
+  async getEnhancedCLIPattern(toolName) {
+    try {
+      if (this.analyzer && this.analyzer.getEnhancedCLIPattern) {
+        return await this.analyzer.getEnhancedCLIPattern(toolName);
+      }
+    } catch (error) {
+      if (process.env.DEBUG === 'true') {
+        console.log(`Error getting enhanced pattern for ${toolName}:`, error.message);
+      }
+    }
+    
+    // Fallback to regular pattern
+    return await this.getOptimizedCLIPattern(toolName);
+  }
+
+  /**
+   * Get routing reasons for debugging
+   */
+  getRoutingReasons(toolName, input, compatibility) {
+    const reasons = [];
+
+    // Input-based reasons
+    const inputLower = input.toLowerCase();
+    if (inputLower.includes(toolName)) {
+      reasons.push(`输入包含工具名称: ${toolName}`);
+    }
+
+    // Compatibility-based reasons
+    if (compatibility.reasons) {
+      reasons.push(...compatibility.reasons);
+    }
+
+    // CLI-specific advantages
+    const cliAdvantages = {
+      'claude': ['高质量输出', '自然语言理解'],
+      'iflow': ['智能工作流', '中文优化'],
+      'qwen': ['优秀的中文语义理解', '位置参数支持'],
+      'codebuddy': ['明确的技能语法', '系统性强'],
+      'qodercli': ['基础分析能力']
+    };
+
+    if (cliAdvantages[toolName]) {
+      reasons.push(...cliAdvantages[toolName]);
+    }
+
+    return reasons;
+  }
+
+  /**
+   * Generate fallback routing options when primary fails
+   */
+  async generateFallbackRoutes(primaryRoute, error) {
+    const fallbackRoutes = [];
+
+    // Get compatibility scores for all valid CLI tools
+    for (const toolName of this.validTools) {
+      if (toolName === primaryRoute.tool) {
+        continue; // Skip the failed tool
+      }
+
+      try {
+        const compatibility = await this.getAgentSkillCompatibilityScore(toolName, primaryRoute.prompt);
+        const enhancedPattern = await this.getEnhancedCLIPattern(toolName);
+
+        if (compatibility.score > 0.3) { // Only consider reasonably compatible tools
+          fallbackRoutes.push({
+            tool: toolName,
+            prompt: primaryRoute.prompt,
+            confidence: compatibility.score * 0.8, // Reduce confidence for fallbacks
+            compatibility,
+            pattern: enhancedPattern,
+            reason: `备用选项 (原工具失败: ${error.message.substring(0, 50)}...)`
+          });
+        }
+      } catch (routeError) {
+        continue; // Skip tools that can't be routed
+      }
+    }
+
+    // Sort by compatibility score
+    fallbackRoutes.sort((a, b) => b.confidence - a.confidence);
+    
+    return fallbackRoutes.slice(0, 3); // Return top 3 fallbacks
+  }
+
+  /**
+   * Enhanced route execution with agent/skill support and fallback
+   */
+  async executeEnhancedRoute(userInput, maxRetries = 2) {
+    let currentRoute = await this.smartRouteEnhanced(userInput);
+    let retryCount = 0;
+
+    while (retryCount <= maxRetries) {
+      try {
+        if (process.env.DEBUG === 'true') {
+          console.log(`[DEBUG] Executing route: ${currentRoute.tool} with confidence ${currentRoute.confidence}`);
+        }
+
+        // Return the successful route
+        return currentRoute;
+
+      } catch (error) {
+        retryCount++;
+        
+        if (retryCount > maxRetries) {
+          // All retries failed, throw the error
+          throw new Error(`Route execution failed after ${maxRetries} retries: ${error.message}`);
+        }
+
+        if (process.env.DEBUG === 'true') {
+          console.log(`[DEBUG] Route failed, generating fallback (attempt ${retryCount}):`, error.message);
+        }
+
+        // Generate fallback routes
+        const fallbackRoutes = await this.generateFallbackRoutes(currentRoute, error);
+        
+        if (fallbackRoutes.length === 0) {
+          throw new Error('No fallback routes available');
+        }
+
+        // Use the best fallback route
+        currentRoute = fallbackRoutes[0];
+        
+        if (process.env.DEBUG === 'true') {
+          console.log(`[DEBUG] Using fallback route: ${currentRoute.tool}`);
+        }
+      }
+    }
+  }
+
+  /**
+   * Batch route multiple inputs efficiently
+   */
+  async batchRouteEnhanced(inputs, options = {}) {
+    const results = [];
+    const { parallel = true, maxConcurrent = 3 } = options;
+
+    if (parallel && inputs.length > 1) {
+      // Process in batches to avoid overwhelming the system
+      const batches = [];
+      for (let i = 0; i < inputs.length; i += maxConcurrent) {
+        batches.push(inputs.slice(i, i + maxConcurrent));
+      }
+
+      for (const batch of batches) {
+        const batchPromises = batch.map(input => this.smartRouteEnhanced(input));
+        const batchResults = await Promise.all(batchPromises);
+        results.push(...batchResults);
+      }
+    } else {
+      // Process sequentially
+      for (const input of inputs) {
+        const result = await this.smartRouteEnhanced(input);
+        results.push(result);
+      }
+    }
+
+    return results;
+  }
 }
 
 module.exports = SmartRouter;

package/src/index.js

@@ -3,15 +3,21 @@
 /**
  * Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System
  * Unified Entry Point
- * International Version - Pure English & ANSI Only
- * Version: 1.0.94
+ * Version: 1.3.1-beta.0
+ *
+ * Migration Note:
+ * - The old monolithic router.js has been archived (2025-12-23)
+ * - Now using router-beta.js with modular command handlers
+ * - See archived_files/ROUTER_JS_ARCHIVE.md for details
  */
 
-// Import all components
+// Import the modular router (router-beta.js)
+const main = require('./cli/router-beta');
+
+// Export core components for backward compatibility
 const MemoryManager = require('./core/memory_manager');
 const StigmergyInstaller = require('./core/installer');
 const { maxOfTwo, isAuthenticated } = require('./utils/helpers');
-const main = require('./cli/router');
 
 // Run the main application
 if (require.main === module) {