stigmergy 1.2.13 → 1.3.2-beta.0

package/test/enhanced-cli-agent-skill-test.js

@@ -0,0 +1,485 @@
+#!/usr/bin/env node
+
+/**
+ * Enhanced CLI Agent and Skill Testing Script
+ * Tests the enhanced CLI calling functionality with agent and skill support
+ */
+
+const path = require('path');
+const os = require('os');
+
+// Import enhanced components
+const CLIHelpAnalyzer = require('../src/core/cli_help_analyzer');
+const SmartRouter = require('../src/core/smart_router');
+
+class EnhancedCLITester {
+  constructor() {
+    this.analyzer = new CLIHelpAnalyzer();
+    this.router = new SmartRouter();
+    this.testResults = {
+      passed: 0,
+      failed: 0,
+      tests: []
+    };
+  }
+
+  /**
+   * Run all tests
+   */
+  async runAllTests() {
+    console.log('🚀 Starting Enhanced CLI Agent and Skill Tests');
+    console.log('=' .repeat(60));
+
+    try {
+      // Initialize components
+      await this.initializeComponents();
+
+      // Run test categories
+      await this.testAnalyzerEnhancedFeatures();
+      await this.testRouterEnhancedFeatures();
+      await this.testSkillMapping();
+      await this.testAgentDetection();
+      await this.testCommandGeneration();
+      await this.testRoutingOptimization();
+
+      // Show results
+      this.showTestResults();
+
+    } catch (error) {
+      console.error('❌ Test suite failed:', error.message);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Initialize test components
+   */
+  async initializeComponents() {
+    console.log('\n📋 Initializing test components...');
+    
+    try {
+      await this.analyzer.initialize();
+      await this.router.initialize();
+      console.log('✅ Components initialized successfully');
+    } catch (error) {
+      console.error('❌ Failed to initialize components:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Test enhanced analyzer features
+   */
+  async testAnalyzerEnhancedFeatures() {
+    console.log('\n🔍 Testing Enhanced Analyzer Features...');
+    
+    const tests = [
+      {
+        name: 'Enhanced CLI Pattern Detection',
+        test: () => this.testEnhancedPatternDetection()
+      },
+      {
+        name: 'Agent Skill Detection',
+        test: () => this.testAgentSkillDetection()
+      },
+      {
+        name: 'Prompt Optimization',
+        test: () => this.testPromptOptimization()
+      }
+    ];
+
+    await this.runTestCategory('Analyzer Enhanced Features', tests);
+  }
+
+  /**
+   * Test enhanced router features
+   */
+  async testRouterEnhancedFeatures() {
+    console.log('\n🧭 Testing Enhanced Router Features...');
+    
+    const tests = [
+      {
+        name: 'Enhanced Smart Routing',
+        test: () => this.testEnhancedSmartRouting()
+      },
+      {
+        name: 'Agent Skill Compatibility Scoring',
+        test: () => this.testCompatibilityScoring()
+      },
+      {
+        name: 'Fallback Route Generation',
+        test: () => this.testFallbackRoutes()
+      }
+    ];
+
+    await this.runTestCategory('Router Enhanced Features', tests);
+  }
+
+  /**
+   * Test skill mapping functionality
+   */
+  async testSkillMapping() {
+    console.log('\n🗺️ Testing Skill Mapping...');
+    
+    const testInputs = [
+      {
+        input: '请使用异化分析技能分析程序员异化现象',
+        expectedSkills: ['异化分析'],
+        expectedCLIs: ['claude', 'iflow', 'qwen', 'codebuddy']
+      },
+      {
+        input: '使用数字马克思智能体进行异化分析',
+        expectedSkills: ['马克思分析', '异化分析'],
+        expectedCLIs: ['claude', 'iflow', 'qwen']
+      }
+    ];
+
+    for (const testCase of testInputs) {
+      await this.runSkillMappingTest(testCase);
+    }
+  }
+
+  /**
+   * Test agent detection
+   */
+  async testAgentDetection() {
+    console.log('\n🤖 Testing Agent Detection...');
+    
+    const agentTestCases = [
+      {
+        input: '请使用异化分析技能分析程序员异化现象',
+        expectedDetections: { hasAgent: true, hasSkill: true }
+      },
+      {
+        input: '使用数字马克思智能体进行阶级分析',
+        expectedDetections: { hasAgent: true, hasSkill: true }
+      },
+      {
+        input: 'codebuddy -y -p "skill:alienation-analysis 分析程序员异化"',
+        expectedDetections: { hasAgent: false, hasSkill: true }
+      }
+    ];
+
+    for (const testCase of agentTestCases) {
+      await this.runAgentDetectionTest(testCase);
+    }
+  }
+
+  /**
+   * Test command generation
+   */
+  async testCommandGeneration() {
+    console.log('\n⚙️ Testing Command Generation...');
+    
+    const commandTestCases = [
+      {
+        cliName: 'claude',
+        prompt: '请使用异化分析技能分析程序员异化现象',
+        expectedFormat: 'claude -p'
+      },
+      {
+        cliName: 'qwen',
+        prompt: '使用数字马克思智能体进行异化分析',
+        expectedFormat: 'qwen'
+      },
+      {
+        cliName: 'codebuddy',
+        prompt: 'skill:alienation-analysis 分析程序员异化现象',
+        expectedFormat: 'codebuddy -y -p'
+      }
+    ];
+
+    for (const testCase of commandTestCases) {
+      await this.runCommandGenerationTest(testCase);
+    }
+  }
+
+  /**
+   * Test routing optimization
+   */
+  async testRoutingOptimization() {
+    console.log('\n🎯 Testing Routing Optimization...');
+    
+    const routingTestCases = [
+      '请使用异化分析技能分析程序员异化现象',
+      '使用数字马克思智能体进行阶级分析',
+      'codebuddy -y -p "skill:alienation-analysis 分析程序员异化"'
+    ];
+
+    for (const input of routingTestCases) {
+      await this.runRoutingOptimizationTest(input);
+    }
+  }
+
+  /**
+   * Run a test category
+   */
+  async runTestCategory(categoryName, tests) {
+    console.log(`\n📊 Running ${categoryName} tests...`);
+    
+    for (const test of tests) {
+      try {
+        await test.test();
+        this.testResults.passed++;
+        this.testResults.tests.push({
+          name: test.name,
+          category: categoryName,
+          status: 'passed'
+        });
+        console.log(`✅ ${test.name}`);
+      } catch (error) {
+        this.testResults.failed++;
+        this.testResults.tests.push({
+          name: test.name,
+          category: categoryName,
+          status: 'failed',
+          error: error.message
+        });
+        console.log(`❌ ${test.name}: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Test enhanced pattern detection
+   */
+  async testEnhancedPatternDetection() {
+    const cliName = 'claude';
+    
+    // Check if analyzer has the enhanced method
+    if (!this.analyzer.getEnhancedCLIPattern) {
+      console.log(`  ⚠️ Enhanced pattern detection not available, skipping test`);
+      return;
+    }
+    
+    const pattern = await this.analyzer.getEnhancedCLIPattern(cliName);
+    
+    if (!pattern) {
+      throw new Error(`Failed to get enhanced pattern for ${cliName}`);
+    }
+
+    if (!pattern.agentSkillSupport) {
+      throw new Error('Enhanced pattern missing agentSkillSupport');
+    }
+
+    console.log(`  📋 Pattern for ${cliName}:`, {
+      supportsAgents: pattern.agentSkillSupport.supportsAgents,
+      supportsSkills: pattern.agentSkillSupport.supportsSkills,
+      naturalLanguageSupport: pattern.agentSkillSupport.naturalLanguageSupport
+    });
+  }
+
+  /**
+   * Test agent skill detection
+   */
+  async testAgentSkillDetection() {
+    const testInput = '请使用异化分析技能分析程序员异化现象';
+    const detections = this.analyzer.detectAgentSkillMentions(testInput, 'claude');
+    
+    if (!detections.hasAgent && !detections.hasSkill) {
+      throw new Error('Failed to detect agent or skill in test input');
+    }
+
+    console.log(`  🔍 Detections for test input:`, detections);
+  }
+
+  /**
+   * Test prompt optimization
+   */
+  async testPromptOptimization() {
+    const originalPrompt = '请使用异化分析技能分析程序员异化现象';
+    const optimizedPrompt = this.analyzer.optimizePromptForCLI(originalPrompt, 'claude', {});
+    
+    if (!optimizedPrompt || optimizedPrompt.length === 0) {
+      throw new Error('Prompt optimization failed');
+    }
+
+    console.log(`  🔧 Optimized prompt: ${optimizedPrompt}`);
+  }
+
+  /**
+   * Test enhanced smart routing
+   */
+  async testEnhancedSmartRouting() {
+    const testInput = '请使用异化分析技能分析程序员异化现象';
+    const route = await this.router.smartRouteEnhanced(testInput);
+    
+    if (!route.tool) {
+      throw new Error('Enhanced routing failed to return tool');
+    }
+
+    console.log(`  🧭 Enhanced route: ${route.tool} (confidence: ${route.confidence})`);
+  }
+
+  /**
+   * Test compatibility scoring
+   */
+  async testCompatibilityScoring() {
+    const compatibility = await this.router.getAgentSkillCompatibilityScore('claude', '请使用异化分析技能分析程序员异化现象');
+    
+    if (!compatibility || typeof compatibility.score !== 'number') {
+      throw new Error('Compatibility scoring failed');
+    }
+
+    console.log(`  📊 Compatibility score for claude: ${compatibility.score}`);
+  }
+
+  /**
+   * Test fallback routes
+   */
+  async testFallbackRoutes() {
+    const primaryRoute = {
+      tool: 'nonexistent',
+      prompt: '测试提示'
+    };
+    const error = new Error('Test error');
+    
+    const fallbacks = await this.router.generateFallbackRoutes(primaryRoute, error);
+    
+    console.log(`  🔄 Generated ${fallbacks.length} fallback routes`);
+  }
+
+  /**
+   * Run skill mapping test
+   */
+  async runSkillMappingTest(testCase) {
+    console.log(`\n  🗺️ Testing skill mapping for: "${testCase.input}"`);
+    
+    for (const cliName of testCase.expectedCLIs) {
+      try {
+        const optimizedCall = this.analyzer.generateOptimizedCall(cliName, testCase.input);
+        if (optimizedCall) {
+          console.log(`    ✅ ${cliName}: ${optimizedCall.fullCommand}`);
+        }
+      } catch (error) {
+        console.log(`    ❌ ${cliName}: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Run agent detection test
+   */
+  async runAgentDetectionTest(testCase) {
+    console.log(`\n  🤖 Testing agent detection for: "${testCase.input}"`);
+    
+    for (const cliName of ['claude', 'qwen', 'codebuddy']) {
+      try {
+        const detections = this.analyzer.detectAgentSkillMentions(testCase.input, cliName);
+        console.log(`    ${cliName}:`, detections);
+        
+        // Check if detection meets expectations
+        const hasExpectedAgent = testCase.expectedDetections.hasAgent === detections.hasAgent;
+        const hasExpectedSkill = testCase.expectedDetections.hasSkill === detections.hasSkill;
+        
+        if (!hasExpectedAgent || !hasExpectedSkill) {
+          console.log(`      ⚠️ Detection mismatch for ${cliName}`);
+        }
+      } catch (error) {
+        console.log(`    ❌ ${cliName}: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Run command generation test
+   */
+  async runCommandGenerationTest(testCase) {
+    console.log(`\n  ⚙️ Testing command generation for ${testCase.cliName}:`);
+    console.log(`    Input: "${testCase.prompt}"`);
+    
+    try {
+      const optimizedCall = this.analyzer.generateOptimizedCall(testCase.cliName, testCase.prompt);
+      if (optimizedCall) {
+        console.log(`    ✅ Generated: ${optimizedCall.fullCommand}`);
+        
+        // Verify format
+        if (!optimizedCall.fullCommand.includes(testCase.expectedFormat)) {
+          console.log(`      ⚠️ Expected format "${testCase.expectedFormat}" not found`);
+        }
+      } else {
+        console.log(`    ❌ Failed to generate command`);
+      }
+    } catch (error) {
+      console.log(`    ❌ Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Run routing optimization test
+   */
+  async runRoutingOptimizationTest(input) {
+    console.log(`\n  🎯 Testing routing optimization for: "${input}"`);
+    
+    try {
+      const route = await this.router.smartRouteEnhanced(input);
+      console.log(`    ✅ Routed to: ${route.tool}`);
+      console.log(`    📊 Confidence: ${route.confidence}`);
+      console.log(`    🔧 Optimized prompt: ${route.prompt}`);
+      
+      if (route.alternativeOptions && route.alternativeOptions.length > 0) {
+        console.log(`    🔄 Alternatives: ${route.alternativeOptions.map(opt => opt.tool).join(', ')}`);
+      }
+    } catch (error) {
+      console.log(`    ❌ Routing failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Show test results summary
+   */
+  showTestResults() {
+    console.log('\n' + '=' .repeat(60));
+    console.log('📊 TEST RESULTS SUMMARY');
+    console.log('=' .repeat(60));
+    
+    console.log(`✅ Passed: ${this.testResults.passed}`);
+    console.log(`❌ Failed: ${this.testResults.failed}`);
+    console.log(`📈 Success Rate: ${((this.testResults.passed / (this.testResults.passed + this.testResults.failed)) * 100).toFixed(1)}%`);
+    
+    if (this.testResults.failed > 0) {
+      console.log('\n❌ Failed Tests:');
+      this.testResults.tests
+        .filter(test => test.status === 'failed')
+        .forEach(test => {
+          console.log(`  - ${test.category}: ${test.name}`);
+          console.log(`    Error: ${test.error}`);
+        });
+    }
+    
+    console.log('\n🎉 Enhanced CLI Agent and Skill Testing Complete!');
+    
+    if (this.testResults.failed === 0) {
+      console.log('✨ All tests passed! Enhanced functionality is working correctly.');
+    } else {
+      console.log('⚠️ Some tests failed. Please check the errors above.');
+    }
+  }
+}
+
+// Main execution
+async function main() {
+  const tester = new EnhancedCLITester();
+  await tester.runAllTests();
+}
+
+// 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 tests if this file is executed directly
+if (require.main === module) {
+  main().catch((error) => {
+    console.error('[FATAL] Test execution failed:', error);
+    process.exit(1);
+  });
+}
+
+module.exports = EnhancedCLITester;