stigmergy 1.2.13 → 1.3.1

package/test/specific-cli-agent-skill-analysis.js

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+
+/**
+ * Specific CLI Agent and Skill Analysis
+ * Analyzes gemini, copilot, codex, and kode CLI tools
+ */
+
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+// Import enhanced components
+const CLIHelpAnalyzer = require('../src/core/cli_help_analyzer');
+const SmartRouter = require('../src/core/smart_router');
+const { CLI_TOOLS } = require('../src/core/cli_tools');
+
+class SpecificCLIAnalyzer {
+  constructor() {
+    this.analyzer = new CLIHelpAnalyzer();
+    this.router = new SmartRouter();
+    this.targetCLIs = ['gemini', 'copilot', 'codex', 'kode'];
+    this.testResults = {};
+  }
+
+  /**
+   * Main analysis function
+   */
+  async analyze() {
+    console.log('🔍 Analyzing Specific CLI Tools for Agent and Skill Support');
+    console.log('=' .repeat(70));
+
+    try {
+      // Initialize components
+      await this.analyzer.initialize();
+      await this.router.initialize();
+
+      // Analyze each target CLI
+      for (const cliName of this.targetCLIs) {
+        await this.analyzeCLI(cliName);
+      }
+
+      // Show comprehensive results
+      this.showAnalysisResults();
+
+    } catch (error) {
+      console.error('❌ Analysis failed:', error.message);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Analyze individual CLI tool
+   */
+  async analyzeCLI(cliName) {
+    console.log(`\n🔧 Analyzing ${cliName.toUpperCase()} CLI...`);
+    console.log('-'.repeat(50));
+
+    this.testResults[cliName] = {
+      installed: false,
+      helpAvailable: false,
+      agentSupport: false,
+      skillSupport: false,
+      commandFormat: null,
+      examples: [],
+      limitations: [],
+      testInputs: []
+    };
+
+    // 1. Check if CLI is installed
+    await this.checkCLIInstallation(cliName);
+
+    // 2. Get help information
+    await this.getCLIHelp(cliName);
+
+    // 3. Test agent/skill detection
+    await this.testAgentSkillDetection(cliName);
+
+    // 4. Test command generation
+    await this.testCommandGeneration(cliName);
+
+    // 5. Test smart routing
+    await this.testSmartRouting(cliName);
+  }
+
+  /**
+   * Check if CLI tool is installed
+   */
+  async checkCLIInstallation(cliName) {
+    try {
+      const result = spawnSync(cliName, ['--version'], {
+        encoding: 'utf8',
+        timeout: 5000,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      if (result.status === 0) {
+        this.testResults[cliName].installed = true;
+        console.log(`✅ ${cliName} is installed`);
+        if (result.stdout) {
+          console.log(`   Version: ${result.stdout.trim()}`);
+        }
+      } else {
+        console.log(`❌ ${cliName} is not installed or not responding`);
+      }
+    } catch (error) {
+      console.log(`❌ ${cliName} not found: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get CLI help information
+   */
+  async getCLIHelp(cliName) {
+    const helpMethods = [
+      ['--help'],
+      ['-h'],
+      ['help'],
+      ['--usage'],
+      [''],
+      ['version'],
+      ['--version']
+    ];
+
+    let helpText = '';
+    let helpMethod = '';
+
+    for (const method of helpMethods) {
+      try {
+        const result = spawnSync(cliName, method, {
+          encoding: 'utf8',
+          timeout: 8000,
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        if (result.status === 0 && result.stdout) {
+          helpText = result.stdout;
+          helpMethod = `${cliName} ${method.join(' ')}`;
+          break;
+        } else if (result.stderr && result.stderr.includes('help')) {
+          helpText = result.stderr;
+          helpMethod = `${cliName} ${method.join(' ')} (stderr)`;
+          break;
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+
+    if (helpText) {
+      this.testResults[cliName].helpAvailable = true;
+      console.log(`📚 Help available via: ${helpMethod}`);
+      
+      // Analyze help text for agent/skill patterns
+      this.analyzeHelpText(cliName, helpText);
+    } else {
+      console.log(`❌ No help information available`);
+    }
+  }
+
+  /**
+   * Analyze help text for agent/skill patterns
+   */
+  analyzeHelpText(cliName, helpText) {
+    const lowerHelp = helpText.toLowerCase();
+
+    // Check for agent-related keywords
+    const agentKeywords = ['agent', '智能体', 'expert', 'specialist', 'assistant'];
+    const hasAgentKeywords = agentKeywords.some(keyword => lowerHelp.includes(keyword));
+
+    // Check for skill-related keywords
+    const skillKeywords = ['skill', '技能', 'capability', 'tool', 'plugin', 'extension'];
+    const hasSkillKeywords = skillKeywords.some(keyword => lowerHelp.includes(keyword));
+
+    // Check for prompt-related parameters
+    const promptParams = ['-p', '--prompt', '--input', '--query', 'positional'];
+    const hasPromptParams = promptParams.some(param => lowerHelp.includes(param));
+
+    // Check for non-interactive modes
+    const nonInteractiveModes = ['non-interactive', 'batch', 'script', 'stdin'];
+    const hasNonInteractive = nonInteractiveModes.some(mode => lowerHelp.includes(mode));
+
+    this.testResults[cliName].agentSupport = hasAgentKeywords;
+    this.testResults[cliName].skillSupport = hasSkillKeywords;
+    this.testResults[cliName].hasPromptParams = hasPromptParams;
+    this.testResults[cliName].hasNonInteractive = hasNonInteractive;
+
+    console.log(`🤖 Agent keywords: ${hasAgentKeywords ? '✅' : '❌'}`);
+    console.log(`🔧 Skill keywords: ${hasSkillKeywords ? '✅' : '❌'}`);
+    console.log(`📝 Prompt params: ${hasPromptParams ? '✅' : '❌'}`);
+    console.log(`🔄 Non-interactive: ${hasNonInteractive ? '✅' : '❌'}`);
+  }
+
+  /**
+   * Test agent/skill detection capabilities
+   */
+  async testAgentSkillDetection(cliName) {
+    const testInputs = [
+      '请使用异化分析技能分析程序员异化现象',
+      '使用数字马克思智能体进行阶级分析',
+      '请专家助手分析技术影响',
+      '使用分析技能进行深度研究'
+    ];
+
+    console.log('\n🧪 Testing agent/skill detection:');
+
+    for (const input of testInputs) {
+      try {
+        const detections = this.analyzer.detectAgentSkillMentions(input, cliName);
+        this.testResults[cliName].testInputs.push({
+          input,
+          detections
+        });
+
+        console.log(`   Input: "${input}"`);
+        console.log(`   Agent: ${detections.hasAgent ? '✅' : '❌'} | Skill: ${detections.hasSkill ? '✅' : '❌'} | Confidence: ${detections.confidence}`);
+      } catch (error) {
+        console.log(`   ❌ Detection failed: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Test command generation
+   */
+  async testCommandGeneration(cliName) {
+    const testPrompt = '请使用异化分析技能分析程序员异化现象';
+    
+    console.log('\n⚙️ Testing command generation:');
+    console.log(`   Test prompt: "${testPrompt}"`);
+
+    try {
+      const optimizedCall = this.analyzer.generateOptimizedCall(cliName, testPrompt);
+      if (optimizedCall) {
+        this.testResults[cliName].commandFormat = optimizedCall.fullCommand;
+        console.log(`   Generated: ${optimizedCall.fullCommand}`);
+      } else {
+        console.log(`   ❌ Command generation failed`);
+      }
+    } catch (error) {
+      console.log(`   ❌ Command generation error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Test smart routing
+   */
+  async testSmartRouting(cliName) {
+    const testInputs = [
+      `请使用分析技能分析程序员异化现象`,
+      `使用数字马克思智能体进行阶级分析`
+    ];
+
+    console.log('\n🧭 Testing smart routing:');
+
+    for (const input of testInputs) {
+      try {
+        const route = await this.router.smartRouteEnhanced(input);
+        if (route.tool === cliName) {
+          console.log(`   ✅ Routed to ${cliName} (confidence: ${route.confidence})`);
+        } else {
+          console.log(`   ⚠️ Routed to ${route.tool} instead of ${cliName}`);
+        }
+      } catch (error) {
+        console.log(`   ❌ Routing failed: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Show comprehensive analysis results
+   */
+  showAnalysisResults() {
+    console.log('\n' + '=' .repeat(70));
+    console.log('📊 COMPREHENSIVE CLI ANALYSIS RESULTS');
+    console.log('=' .repeat(70));
+
+    for (const [cliName, results] of Object.entries(this.testResults)) {
+      console.log(`\n🔧 ${cliName.toUpperCase()} CLI ANALYSIS`);
+      console.log('-'.repeat(50));
+
+      // Installation status
+      console.log(`📦 Installation: ${results.installed ? '✅ Installed' : '❌ Not Installed'}`);
+      
+      // Help availability
+      console.log(`📚 Help Available: ${results.helpAvailable ? '✅ Yes' : '❌ No'}`);
+
+      // Agent/Skill support
+      console.log(`🤖 Agent Support: ${results.agentSupport ? '✅ Yes' : '❌ No'}`);
+      console.log(`🔧 Skill Support: ${results.skillSupport ? '✅ Yes' : '❌ No'}`);
+
+      // Command format
+      if (results.commandFormat) {
+        console.log(`⚙️ Command Format: ${results.commandFormat}`);
+      }
+
+      // Test inputs summary
+      if (results.testInputs.length > 0) {
+        console.log(`🧪 Detection Tests: ${results.testInputs.length} completed`);
+        const avgConfidence = results.testInputs.reduce((sum, test) => sum + test.detections.confidence, 0) / results.testInputs.length;
+        console.log(`   Average Confidence: ${avgConfidence.toFixed(2)}`);
+      }
+
+      // Overall assessment
+      const supportScore = (results.agentSupport ? 1 : 0) + (results.skillSupport ? 1 : 0);
+      let assessment = '';
+      
+      if (supportScore === 2) {
+        assessment = '✅ Full Support';
+      } else if (supportScore === 1) {
+        assessment = '⚠️ Partial Support';
+      } else {
+        assessment = '❌ No Support';
+      }
+
+      console.log(`🎯 Overall Assessment: ${assessment}`);
+    }
+
+    // Summary comparison
+    console.log('\n' + '=' .repeat(70));
+    console.log('📋 SUMMARY COMPARISON');
+    console.log('=' .repeat(70));
+
+    const comparisonTable = [
+      ['CLI Tool', 'Installed', 'Agent Support', 'Skill Support', 'Overall'],
+      ['-'.repeat(10), '-'.repeat(10), '-'.repeat(12), '-'.repeat(12), '-'.repeat(8)]
+    ];
+
+    for (const [cliName, results] of Object.entries(this.testResults)) {
+      const installed = results.installed ? '✅' : '❌';
+      const agent = results.agentSupport ? '✅' : '❌';
+      const skill = results.skillSupport ? '✅' : '❌';
+      
+      const supportScore = (results.agentSupport ? 1 : 0) + (results.skillSupport ? 1 : 0);
+      const overall = supportScore === 2 ? 'Excellent' : supportScore === 1 ? 'Good' : 'Poor';
+
+      comparisonTable.push([cliName, installed, agent, skill, overall]);
+    }
+
+    // Print table
+    for (const row of comparisonTable) {
+      console.log(row.join(' | '));
+    }
+
+    // Recommendations
+    console.log('\n💡 RECOMMENDATIONS');
+    console.log('-'.repeat(30));
+    
+    for (const [cliName, results] of Object.entries(this.testResults)) {
+      if (!results.installed) {
+        console.log(`📦 ${cliName}: Consider installing for broader CLI tool coverage`);
+      } else if (!results.agentSupport || !results.skillSupport) {
+        console.log(`🔧 ${cliName}: Limited agent/skill support - may need manual prompt engineering`);
+      } else {
+        console.log(`✨ ${cliName}: Full support available - ready for enhanced CLI calls`);
+      }
+    }
+  }
+}
+
+// Main execution
+async function main() {
+  const analyzer = new SpecificCLIAnalyzer();
+  await analyzer.analyze();
+}
+
+// Handle errors
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('[FATAL] Unhandled Rejection at:', promise, 'reason:', reason);
+  process.exit(1);
+});
+
+process.on('uncaughtException', (error) => {
+  console.error('[FATAL] Uncaught Exception:', error);
+  process.exit(1);
+});
+
+// Run analysis if this file is executed directly
+if (require.main === module) {
+  main().catch((error) => {
+    console.error('[FATAL] Analysis execution failed:', error);
+    process.exit(1);
+  });
+}
+
+module.exports = SpecificCLIAnalyzer;

package/test/unit/smart_router.test.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+
+/**
+ * 单元测试：智能路由模块
+ * 测试SmartRouter类的各种路由功能
+ */
+
+const SmartRouter = require('../../src/core/smart_router');
+const CLIHelpAnalyzer = require('../../src/core/cli_help_analyzer');
+const { CLI_TOOLS } = require('../../src/core/cli_tools');
+
+// 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('SmartRouter', () => {
+  let router;
+
+  beforeEach(async () => {
+    router = new SmartRouter();
+    await router.initialize();
+  });
+
+  describe('smartRoute', () => {
+    test('should route to claude when claude keyword is detected', async () => {
+      const result = await router.smartRoute('用claude分析这段代码');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('分析这段代码');
+    });
+
+    test('should route to qwen when qwen keyword is detected', async () => {
+      const result = await router.smartRoute('用qwen写一个hello world程序');
+      expect(result.tool).toBe('qwen');
+      expect(result.prompt).toBe('写一个hello world程序');
+    });
+
+    test('should route to gemini when gemini keyword is detected', async () => {
+      const result = await router.smartRoute('请使用gemini解释这段代码');
+      expect(result.tool).toBe('gemini');
+      expect(result.prompt).toBe('解释这段代码');
+    });
+
+    test('should route to default tool when no keyword is detected', async () => {
+      const result = await router.smartRoute('分析项目架构');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('分析项目架构');
+    });
+
+    test('should route to claude when "use claude" pattern is detected', async () => {
+      const result = await router.smartRoute('use claude to explain this code');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('explain this code');
+    });
+
+    test('should route to qwen when "using qwen" pattern is detected', async () => {
+      const result = await router.smartRoute('using qwen to generate documentation');
+      expect(result.tool).toBe('qwen');
+      expect(result.prompt).toBe('generate documentation');
+    });
+
+    test('should handle multiple tool keywords and prioritize exact matches', async () => {
+      const result = await router.smartRoute('use claude and qwen to analyze code');
+      expect(result.tool).toBe('claude'); // Should prioritize the first matching tool
+      expect(result.prompt).toBe('and qwen to analyze code');
+    });
+
+    test('should clean up common prefixes from prompts', async () => {
+      const result = await router.smartRoute('please help me with this code using claude');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('with this code');
+    });
+
+    test('should handle "with" keyword for tool selection', async () => {
+      const result = await router.smartRoute('write an article with qwen');
+      expect(result.tool).toBe('qwen');
+      expect(result.prompt).toBe('write an article');
+    });
+
+    test('should handle empty input gracefully', async () => {
+      const result = await router.smartRoute('');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('');
+    });
+
+    test('should handle input with only whitespace', async () => {
+      const result = await router.smartRoute('   ');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('');
+    });
+  });
+
+  describe('shouldRoute', () => {
+    test('should return true for inputs containing route keywords', () => {
+      expect(router.shouldRoute('use claude to analyze')).toBe(true);
+      expect(router.shouldRoute('please help with')).toBe(true);
+      expect(router.shouldRoute('write code using qwen')).toBe(true);
+      expect(router.shouldRoute('explain this with gemini')).toBe(true);
+    });
+
+    test('should return false for inputs without route keywords', () => {
+      expect(router.shouldRoute('hello world')).toBe(false);
+      expect(router.shouldRoute('test input')).toBe(false);
+      expect(router.shouldRoute('')).toBe(false);
+      expect(router.shouldRoute(null)).toBe(false);
+      expect(router.shouldRoute(undefined)).toBe(false);
+    });
+
+    test('should handle non-string inputs', () => {
+      expect(router.shouldRoute(123)).toBe(false);
+      expect(router.shouldRoute({})).toBe(false);
+      expect(router.shouldRoute([])).toBe(false);
+    });
+  });
+
+  describe('extractKeywords', () => {
+    test('should extract correct keywords for claude', () => {
+      const keywords = router.extractKeywords('claude', null);
+      expect(keywords).toContain('claude');
+      expect(keywords).toContain('anthropic');
+    });
+
+    test('should extract correct keywords for qwen', () => {
+      const keywords = router.extractKeywords('qwen', null);
+      expect(keywords).toContain('qwen');
+      expect(keywords).toContain('alibaba');
+      expect(keywords).toContain('tongyi');
+    });
+
+    test('should extract correct keywords for gemini', () => {
+      const keywords = router.extractKeywords('gemini', null);
+      expect(keywords).toContain('gemini');
+      expect(keywords).toContain('google');
+    });
+
+    test('should extract correct keywords for iflow', () => {
+      const keywords = router.extractKeywords('iflow', null);
+      expect(keywords).toContain('iflow');
+      expect(keywords).toContain('workflow');
+      expect(keywords).toContain('intelligent');
+    });
+
+    test('should extract correct keywords for codebuddy', () => {
+      const keywords = router.extractKeywords('codebuddy', null);
+      expect(keywords).toContain('codebuddy');
+      expect(keywords).toContain('buddy');
+      expect(keywords).toContain('assistant');
+    });
+
+    test('should extract correct keywords for copilot', () => {
+      const keywords = router.extractKeywords('copilot', null);
+      expect(keywords).toContain('copilot');
+      expect(keywords).toContain('github');
+      expect(keywords).toContain('gh');
+    });
+
+    test('should extract correct keywords for codex', () => {
+      const keywords = router.extractKeywords('codex', null);
+      expect(keywords).toContain('codex');
+      expect(keywords).toContain('openai');
+      expect(keywords).toContain('gpt');
+    });
+
+    test('should extract correct keywords for qodercli', () => {
+      const keywords = router.extractKeywords('qodercli', null);
+      expect(keywords).toContain('qodercli');
+      expect(keywords).toContain('qoder');
+      expect(keywords).toContain('code');
+    });
+
+    test('should extract correct keywords for kode', () => {
+      const keywords = router.extractKeywords('kode', null);
+      expect(keywords).toContain('kode');
+      expect(keywords).toContain('multi-model');
+      expect(keywords).toContain('collaboration');
+      expect(keywords).toContain('multi模型');
+    });
+  });
+
+  describe('smartRouteEnhanced', () => {
+    test('should return enhanced routing results with confidence scores', async () => {
+      const result = await router.smartRouteEnhanced('用claude分析这段代码');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('分析这段代码');
+      expect(result.confidence).toBeDefined();
+      expect(typeof result.confidence).toBe('number');
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    });
+
+    test('should return alternative options when available', async () => {
+      const result = await router.smartRouteEnhanced('用qwen写一个hello world程序');
+      expect(result.tool).toBe('qwen');
+      expect(result.alternativeOptions).toBeDefined();
+      expect(Array.isArray(result.alternativeOptions)).toBe(true);
+    });
+  });
+
+  describe('isRecentFailure', () => {
+    test('should return true for failures within 1 hour', () => {
+      const recentTime = new Date(Date.now() - 30 * 60 * 1000); // 30 minutes ago
+      expect(router.isRecentFailure(recentTime.toISOString())).toBe(true);
+    });
+
+    test('should return false for failures older than 1 hour', () => {
+      const oldTime = new Date(Date.now() - 2 * 60 * 60 * 1000); // 2 hours ago
+      expect(router.isRecentFailure(oldTime.toISOString())).toBe(false);
+    });
+  });
+});
+
+// Additional integration tests
+describe('SmartRouter Integration Tests', () => {
+  let router;
+
+  beforeEach(async () => {
+    router = new SmartRouter();
+    await router.initialize();
+  });
+
+  test('should handle complex routing scenarios with multiple keywords', async () => {
+    const scenarios = [
+      { input: '请用claude帮我分析这段JavaScript代码的性能问题', expectedTool: 'claude', expectedPrompt: '帮我分析这段JavaScript代码的性能问题' },
+      { input: '使用qwen写一份技术文档，关于Node.js', expectedTool: 'qwen', expectedPrompt: '写一份技术文档，关于Node.js' },
+      { input: '请gemini解释一下机器学习的基本概念', expectedTool: 'gemini', expectedPrompt: '解释一下机器学习的基本概念' },
+      { input: '用codebuddy帮我修复这个bug', expectedTool: 'codebuddy', expectedPrompt: '帮我修复这个bug' },
+      { input: '通过copilot生成一个React组件', expectedTool: 'copilot', expectedPrompt: '生成一个React组件' }
+    ];
+
+    for (const scenario of scenarios) {
+      const result = await router.smartRoute(scenario.input);
+      expect(result.tool).toBe(scenario.expectedTool);
+      expect(result.prompt).toBe(scenario.expectedPrompt);
+    }
+  });
+
+  test('should handle mixed language inputs (Chinese + English)', async () => {
+    const result = await router.smartRoute('Use claude to analyze this code and explain it in Chinese');
+    expect(result.tool).toBe('claude');
+    expect(result.prompt).toBe('to analyze this code and explain it in Chinese');
+  });
+
+  test('should handle routing with specific tool subcommands', async () => {
+    // Mock CLI pattern with subcommands
+    router.getOptimizedCLIPattern = jest.fn().mockResolvedValue({
+      patterns: {
+        commands: [{ name: 'analyze' }, { name: 'generate' }, { name: 'explain' }]
+      }
+    });
+
+    const result = await router.smartRoute('claude analyze this file');
+    expect(result.tool).toBe('claude');
+    expect(result.prompt).toBe('analyze this file');
+  });
+});