stigmergy 1.2.13 → 1.3.1-beta

package/src/core/cli_help_analyzer.js

@@ -1,4 +1,20 @@
-// Enhanced CLI Help Analyzer with better pattern extraction
+/**
+ * Enhanced CLI Help Analyzer with better pattern extraction
+ * 
+ * 📚 参考文档：
+ * - 重构文档：REFACTORING_CLI_HELP_ANALYZER.md
+ * - 实现清单：IMPLEMENTATION_CHECKLIST_CLI_HELP_ANALYZER_REFACTOR.md
+ * - 设计文档：DESIGN_CLI_HELP_ANALYZER_REFACTOR.md
+ * - 规格说明：SPECS_CLI_HELP_ANALYZER_REFACTOR.md
+ * 
+ * 🎯 重构说明（v1.4.0）：
+ * - 统一 analyzeCLI() 入口点，支持 options 参数
+ * - 提取 addEnhancedInfo() 方法，实现不可变对象模式
+ * - 简化包装器方法（getCLIPattern, getEnhancedCLIPattern, analyzeCLIEnhanced）
+ * - 所有方法保持向后兼容，已添加 @deprecated 注释
+ * 
+ * 🧪 测试覆盖：36/36 测试通过（23单元测试 + 13集成测试）
+ */
 const { spawnSync } = require('child_process');
 const fs = require('fs/promises');
 const path = require('path');
@@ -13,6 +29,180 @@ class CLIHelpAnalyzer {
     this.lastAnalysisFile = path.join(this.configDir, 'last-analysis.json');
     this.cliTools = CLI_TOOLS;
 
+    // Enhanced CLI Agent and Skill Patterns Configuration
+    this.enhancedPatterns = {
+      'claude': {
+        commandFormat: 'claude -p "{prompt}"',
+        agentDetection: true,
+        skillDetection: true,
+        naturalLanguageSupport: true,
+        agentTypes: ['expert', 'skill', 'analysis', 'agent'],
+        skillKeywords: ['技能', '智能体', '分析', '工具', '方法'],
+        examples: [
+          'claude -p "请使用异化分析技能分析程序员异化现象"',
+          'claude -p "请使用数字马克思智能体进行阶级分析"'
+        ]
+      },
+      'iflow': {
+        commandFormat: 'iflow -p "{prompt}"',
+        agentDetection: true,
+        skillDetection: true,
+        naturalLanguageSupport: true,
+        agentTypes: ['expert', 'skill', 'analysis', 'agent'],
+        skillKeywords: ['技能', '智能体', '分析', '工具', '方法'],
+        examples: [
+          'iflow -p "请使用异化分析技能分析程序员异化现象"',
+          'iflow -p "请使用数字马克思智能体进行异化分析"'
+        ]
+      },
+      'qwen': {
+        commandFormat: 'qwen "{prompt}"',
+        agentDetection: true,
+        skillDetection: true,
+        naturalLanguageSupport: true,
+        positionalArgs: true,
+        agentTypes: ['expert', 'skill', 'analysis', 'agent'],
+        skillKeywords: ['智能体', '分析技能', '马克思', '异化', '阶级'],
+        examples: [
+          'qwen "使用数字马克思智能体进行异化分析，分析程序员的技术异化现象"',
+          'qwen "使用异化分析技能分析程序员在AI开发中的异化现象"'
+        ]
+      },
+      'codebuddy': {
+        commandFormat: 'codebuddy -y -p "{prompt}"',
+        agentDetection: false,
+        skillDetection: true,
+        skillPrefixRequired: true,
+        agentTypes: ['skill'],
+        skillKeywords: ['skill:', '技能', '分析'],
+        examples: [
+          'codebuddy -y -p "skill:alienation-analysis 分析程序员异化现象"',
+          'codebuddy -y -p "skill:marxist-analysis 分析技术异化"'
+        ]
+      },
+      'qodercli': {
+        commandFormat: 'qodercli -p "{prompt}"',
+        agentDetection: false,
+        skillDetection: false,
+        basicAISupport: true,
+        agentTypes: ['basic'],
+        skillKeywords: ['分析', '理解'],
+        examples: [
+          'qodercli -p "分析程序员在AI开发中的异化现象"',
+          'qodercli -p "进行技术异化的基础分析"'
+        ]
+      },
+      'gemini': {
+        commandFormat: 'gemini -p "{prompt}"',
+        agentDetection: true,
+        skillDetection: true,
+        naturalLanguageSupport: true,
+        agentTypes: ['expert', 'skill', 'analysis', 'agent'],
+        skillKeywords: ['技能', '智能体', '分析', '工具', '方法'],
+        examples: [
+          'gemini -p "请使用分析技能分析程序员异化现象"',
+          'gemini -p "使用智能体进行技术分析"'
+        ]
+      },
+      'copilot': {
+        commandFormat: 'copilot "{prompt}"',
+        agentDetection: true,
+        skillDetection: true,
+        naturalLanguageSupport: true,
+        positionalArgs: true,
+        agentTypes: ['expert', 'skill', 'analysis', 'agent'],
+        skillKeywords: ['技能', '智能体', '分析', '工具', '方法'],
+        examples: [
+          'copilot "请使用分析技能分析程序员异化现象"',
+          'copilot "使用智能体进行技术分析"'
+        ]
+      },
+      'codex': {
+        commandFormat: 'codex -m gpt-5 "{prompt}"',
+        agentDetection: true,
+        skillDetection: true,
+        naturalLanguageSupport: true,
+        positionalArgs: true,
+        agentTypes: ['expert', 'skill', 'analysis', 'agent'],
+        skillKeywords: ['技能', '智能体', '分析', '工具', '方法', '代码', '审查'],
+        examples: [
+          'codex "请使用异化分析技能分析程序员异化现象"',
+          'codex exec "使用数字马克思智能体分析代码库"',
+          'codex review "分析这段代码的异化现象"'
+        ]
+      },
+      'kode': {
+        commandFormat: 'kode -p "{prompt}"',
+        agentDetection: true,
+        skillDetection: true,
+        naturalLanguageSupport: true,
+        positionalArgs: true,
+        agentTypes: ['expert', 'skill', 'analysis', 'agent'],
+        skillKeywords: ['技能', '智能体', '分析', '工具', '方法', '多模型', '协作'],
+        examples: [
+          'kode -p "请使用异化分析技能分析程序员异化现象"',
+          'kode -p "使用数字马克思智能体进行异化分析"',
+          'kode -p "@ask-claude-sonnet-4 分析这个问题"'
+        ]
+      }
+    };
+
+    // Agent and Skill Recognition Patterns
+    this.agentSkillPatterns = {
+      // Agent type detection patterns
+      agentTypes: {
+        'expert': ['专家', 'expert', 'specialist', '马克思', 'marxist', '数字马克思'],
+        'skill': ['技能', 'skill', '能力', '方法', '工具'],
+        'analysis': ['分析', 'analysis', '解析', '评估'],
+        'agent': ['智能体', 'agent', '助手', '助手'],
+        'basic': ['基础', 'basic', '简单', '初步']
+      },
+      
+      // Skill name patterns for different CLIs
+      skillMapping: {
+        '异化分析': {
+          'claude': '异化分析技能',
+          'iflow': '异化分析技能',
+          'qwen': '异化分析技能',
+          'codebuddy': 'alienation-analysis',
+          'gemini': '异化分析技能',
+          'copilot': '异化分析技能',
+          'codex': 'alienation-analysis',
+          'kode': '异化分析技能'
+        },
+        '马克思分析': {
+          'claude': '数字马克思智能体',
+          'iflow': '数字马克思智能体',
+          'qwen': '数字马克思智能体',
+          'codebuddy': 'marxist-analysis',
+          'gemini': '马克思分析技能',
+          'copilot': '马克思分析智能体',
+          'codex': 'marxist-analysis',
+          'kode': '数字马克思智能体'
+        },
+        '技术分析': {
+          'claude': '技术分析技能',
+          'iflow': '技术分析技能',
+          'qwen': '技术分析技能',
+          'codebuddy': 'tech-analysis',
+          'gemini': '技术分析技能',
+          'copilot': '技术分析技能',
+          'codex': 'tech-analysis',
+          'kode': '技术分析技能'
+        },
+        '阶级分析': {
+          'claude': '阶级分析技能',
+          'iflow': '阶级分析技能',
+          'qwen': '阶级分析技能',
+          'codebuddy': 'class-analysis',
+          'gemini': '阶级分析技能',
+          'copilot': '阶级分析技能',
+          'codex': 'class-analysis',
+          'kode': '阶级分析技能'
+        }
+      }
+    };
+
     // Pattern recognition rules for different CLI types
     this.patternRules = {
       // OpenAI style CLI (codex, chatgpt)
@@ -95,16 +285,28 @@ class CLIHelpAnalyzer {
   }
 
   /**
-   * Analyze all configured CLI tools with optimized error handling
+   * 分析所有配置的CLI工具
+   * @param {Object} options - 分析选项
+   * @param {boolean} options.enhanced - 是否返回增强信息
+   * @param {boolean} options.forceRefresh - 是否强制刷新缓存
+   * @returns {Promise<Object>} 所有CLI的分析结果
    */
-  async analyzeAllCLI() {
+  async analyzeAllCLI(options = {}) {
     const results = {};
-    for (const [cliName, _] of Object.entries(this.cliTools)) {
+    const cliNames = Object.keys(this.cliTools);
+    
+    // 优化：并行分析所有 CLI，添加超时保护
+    const analysisPromises = cliNames.map(async (cliName) => {
       try {
         if (process.env.DEBUG === 'true') {
           console.log(`Analyzing ${cliName}...`);
         }
-        results[cliName] = await this.analyzeCLI(cliName);
+        // 添加超时保护，单个 CLI 分析最多 60 秒（因为需要尝试多个 help 方法）
+        const timeoutPromise = new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('Analysis timeout')), 60000)
+        );
+        const result = await Promise.race([this.analyzeCLI(cliName, options), timeoutPromise]);
+        return { cliName, result };
       } catch (error) {
         // Only log important errors, suppress expected file not found errors
         if (
@@ -112,7 +314,8 @@ class CLIHelpAnalyzer {
           !error.message.includes('no such file or directory') &&
           !error.message.includes(
             'not recognized as an internal or external command',
-          )
+          ) &&
+          !error.message.includes('Analysis timeout')
         ) {
           await errorHandler.logError(
             error,
@@ -120,21 +323,64 @@ class CLIHelpAnalyzer {
             `CLIHelpAnalyzer.analyzeAllCLI.${cliName}`,
           );
         }
-        results[cliName] = { success: false, error: error.message };
+        return { cliName, result: { success: false, error: error.message } };
       }
+    });
+
+    // 等待所有分析完成，添加整体超时保护
+    const overallTimeoutPromise = new Promise((_, reject) => 
+      setTimeout(() => reject(new Error('Overall analysis timeout')), 120000)
+    );
+    const analysisResults = await Promise.race([Promise.all(analysisPromises), overallTimeoutPromise]);
+    
+    // 整理结果
+    for (const { cliName, result } of analysisResults) {
+      results[cliName] = result;
     }
+    
     return results;
   }
 
   /**
-   * Analyze specific CLI tool
+   * 分析CLI工具
+   * @param {string} cliName - CLI工具名称
+   * @param {Object} options - 分析选项
+   * @param {boolean} options.enhanced - 是否返回增强信息
+   * @param {boolean} options.forceRefresh - 是否强制刷新缓存
+   * @returns {Promise<Object>} 分析结果
    */
-  async analyzeCLI(cliName) {
+  async analyzeCLI(cliName, options = {}) {
+    const { enhanced = false, forceRefresh = false } = options;
     const cliConfig = this.cliTools[cliName];
     if (!cliConfig) {
       throw new Error(`CLI tool ${cliName} not found in configuration`);
     }
     try {
+      // 检查是否强制刷新
+      if (!forceRefresh) {
+        // 优化：检查缓存版本，只在版本变化时重新分析
+        const cachedAnalysis = await this.getCachedAnalysis(cliName);
+        if (cachedAnalysis && cachedAnalysis.success) {
+          // 获取当前版本
+          const currentVersion = await this.getCurrentVersion(cliName, cliConfig);
+          // 如果版本未变化，使用缓存
+          if (currentVersion === cachedAnalysis.version && !this.isCacheExpired(cachedAnalysis.timestamp)) {
+            if (process.env.DEBUG === 'true') {
+              console.log(`[DEBUG] ${cliName}: 使用缓存的分析结果 (版本: ${cachedAnalysis.version})`);
+            }
+            // 添加增强信息
+            if (enhanced) {
+              return this.addEnhancedInfo(cachedAnalysis, cliName);
+            }
+            return cachedAnalysis;
+          } else {
+            if (process.env.DEBUG === 'true') {
+              console.log(`[DEBUG] ${cliName}: 版本变化 (${cachedAnalysis.version} -> ${currentVersion}) 或缓存过期，重新分析`);
+            }
+          }
+        }
+      }
+      
       // Get help information
       const helpInfo = await this.getHelpInfo(cliName, cliConfig);
       // Detect CLI type
@@ -161,6 +407,10 @@ class CLIHelpAnalyzer {
       };
       // Cache the analysis
       await this.cacheAnalysis(cliName, analysis);
+      // 添加增强信息
+      if (enhanced) {
+        return this.addEnhancedInfo(analysis, cliName);
+      }
       return analysis;
     } catch (error) {
       // Record failed attempt but suppress error if it's an expected issue
@@ -184,6 +434,33 @@ class CLIHelpAnalyzer {
     }
   }
 
+  /**
+   * 添加增强信息
+   * @param {Object} analysis - 基础分析结果
+   * @param {string} cliName - CLI工具名称
+   * @returns {Object} 增强分析结果
+   * @重要说明：必须返回新对象，不能修改原对象
+   */
+  addEnhancedInfo(analysis, cliName) {
+    const enhancedPatterns = this.enhancedPatterns[cliName] || {};
+    
+    // 使用展开运算符创建新对象，不修改原对象
+    return {
+      ...analysis,
+      agentSkillSupport: {
+        supportsAgents: enhancedPatterns.agentDetection || false,
+        supportsSkills: enhancedPatterns.skillDetection || false,
+        naturalLanguageSupport: enhancedPatterns.naturalLanguageSupport || false,
+        skillPrefixRequired: enhancedPatterns.skillPrefixRequired || false,
+        positionalArgs: enhancedPatterns.positionalArgs || false,
+        agentTypes: enhancedPatterns.agentTypes || [],
+        skillKeywords: enhancedPatterns.skillKeywords || [],
+        commandFormat: enhancedPatterns.commandFormat || "",
+        examples: enhancedPatterns.examples || []
+      }
+    };
+  }
+
   /**
    * Get help information using multiple methods
    */
@@ -194,14 +471,8 @@ class CLIHelpAnalyzer {
     }
 
     const helpMethods = [
-      ['--help'],
-      ['-h'],
-      ['help'],
-      ['--usage'],
-      [''],
-      ['version'],
-      ['--version'],
-      ['-v'],
+      ['--help'],  // 最常用
+      ['-h'],      // 常用
     ];
     let rawHelp = '';
     let version = 'unknown';
@@ -211,7 +482,7 @@ class CLIHelpAnalyzer {
       try {
         const result = spawnSync(cliName, helpArgs, {
           encoding: 'utf8',
-          timeout: 15000,
+          timeout: 5000,
           shell: true,
         });
         if (result.status === 0 && result.stdout) {
@@ -233,11 +504,10 @@ class CLIHelpAnalyzer {
       try {
         const versionCmd = cliConfig.version.split(' ');
         const versionResult = spawnSync(versionCmd[0], versionCmd.slice(1), {
-          encoding: 'utf8',
-          timeout: 10000,
-          shell: true,
-        });
-        if (versionResult.status === 0) {
+                encoding: 'utf8',
+                timeout: 3000, // 优化：减少超时时间从 10 秒到 3 秒
+                shell: true,
+              });        if (versionResult.status === 0) {
           version = versionResult.stdout.trim() || versionResult.stderr.trim();
         }
       } catch (error) {
@@ -403,7 +673,10 @@ class CLIHelpAnalyzer {
         option.includes('non-interactive') ||
         option.includes('batch') ||
         option.includes('no-input') ||
-        option.includes('stdin'),
+        option.includes('stdin') ||
+        option.includes('print') ||  // For CLI tools like kode with --print flag
+        option.includes('pipe') ||    // Pipes mentioned in description
+        option.includes('exit'),      // Exit after execution
     );
     patterns.nonInteractiveFlag =
       nonInteractiveFlags.length > 0 ? nonInteractiveFlags[0] : null;
@@ -540,10 +813,13 @@ class CLIHelpAnalyzer {
   }
   
   /**
-   * Get CLI pattern (wrapper for getCachedAnalysis)
+   * 获取CLI模式（包装器方法）
+   * @deprecated 此方法已弃用，请使用 analyzeCLI(cliName, { enhanced: false }) 代替
+   * @param {string} cliName - CLI工具名称
+   * @returns {Promise<Object>} 分析结果
    */
   async getCLIPattern(cliName) {
-    return await this.getCachedAnalysis(cliName);
+    return await this.analyzeCLI(cliName, { enhanced: false });
   }
 
   /**
@@ -598,6 +874,28 @@ class CLIHelpAnalyzer {
     }
   }
 
+  /**
+   * Get current CLI version
+   */
+  async getCurrentVersion(cliName, cliConfig) {
+    try {
+      const versionCmd = cliConfig.version || `${cliName} --version`;
+      const result = spawnSync(versionCmd.split(' ')[0], versionCmd.split(' ').slice(1), {
+        encoding: 'utf8',
+        shell: true,
+        timeout: 3000,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      
+      if (result.status === 0) {
+        return (result.stdout.trim() || result.stderr.trim()).split('\n')[0];
+      }
+      return 'unknown';
+    } catch (error) {
+      return 'unknown';
+    }
+  }
+
   /**
    * Record failed attempt
    */
@@ -675,6 +973,264 @@ class CLIHelpAnalyzer {
   setCLITools(tools) {
     this.cliTools = tools;
   }
+
+  /**
+   * 增强分析，包含智能体和技能检测（包装器方法）
+   * @deprecated 此方法已弃用，请使用 analyzeCLI(cliName, { enhanced: true }) 代替
+   * @param {string} cliName - CLI工具名称
+   * @returns {Promise<Object>} 增强分析结果
+   */
+  async analyzeCLIEnhanced(cliName) {
+    return await this.analyzeCLI(cliName, { enhanced: true });
+  }
+
+  /**
+   * Detect agent and skill mentions in user input
+   */
+  detectAgentSkillMentions(input, cliName) {
+    const enhancedPattern = this.enhancedPatterns[cliName];
+    if (!enhancedPattern) {
+      return { hasAgent: false, hasSkill: false, confidence: 0 };
+    }
+
+    const inputLower = input.toLowerCase();
+    let hasAgent = false;
+    let hasSkill = false;
+    let confidence = 0;
+
+    // Check for agent keywords
+    if (enhancedPattern.agentDetection) {
+      const agentKeywords = [
+        ...this.agentSkillPatterns.agentTypes['expert'],
+        ...this.agentSkillPatterns.agentTypes['agent'],
+        ...enhancedPattern.skillKeywords
+      ];
+
+      for (const keyword of agentKeywords) {
+        if (inputLower.includes(keyword.toLowerCase())) {
+          hasAgent = true;
+          confidence += 0.3;
+          break;
+        }
+      }
+    }
+
+    // Check for skill keywords
+    if (enhancedPattern.skillDetection) {
+      const skillKeywords = enhancedPattern.skillKeywords;
+      
+      for (const keyword of skillKeywords) {
+        if (inputLower.includes(keyword.toLowerCase())) {
+          hasSkill = true;
+          confidence += 0.4;
+          break;
+        }
+      }
+
+      // Special check for skill: prefix (codebuddy)
+      if (enhancedPattern.skillPrefixRequired && inputLower.includes('skill:')) {
+        hasSkill = true;
+        confidence += 0.6;
+      }
+    }
+
+    // Boost confidence based on CLI-specific patterns
+    if (cliName === 'qwen' && enhancedPattern.positionalArgs) {
+      // Qwen CLI has higher confidence for natural language
+      confidence *= 1.2;
+    }
+
+    return { hasAgent, hasSkill, confidence: Math.min(confidence, 1.0) };
+  }
+
+  /**
+   * Optimize prompt for specific CLI tool
+   */
+  optimizePromptForCLI(prompt, cliName, detectedMentions) {
+    const enhancedPattern = this.enhancedPatterns[cliName];
+    if (!enhancedPattern) {
+      return prompt;
+    }
+
+    let optimizedPrompt = prompt;
+
+    // Apply skill mapping if applicable
+    for (const [chineseSkill, mapping] of Object.entries(this.agentSkillPatterns.skillMapping)) {
+      if (prompt.includes(chineseSkill) && mapping[cliName]) {
+        if (enhancedPattern.skillPrefixRequired && !prompt.includes('skill:')) {
+          // For codebuddy, add skill: prefix
+          optimizedPrompt = prompt.replace(
+            chineseSkill, 
+            `skill:${mapping[cliName]}`
+          );
+        } else if (enhancedPattern.naturalLanguageSupport) {
+          // For CLIs that support natural language, use the mapped term
+          optimizedPrompt = prompt.replace(
+            chineseSkill, 
+            mapping[cliName]
+          );
+        }
+        break;
+      }
+    }
+
+    return optimizedPrompt;
+  }
+
+  /**
+   * 获取增强CLI模式，包含智能体/技能支持（包装器方法）
+   * @deprecated 此方法已弃用，请使用 analyzeCLI(cliName, { enhanced: true }) 代替
+   * @param {string} cliName - CLI工具名称
+   * @returns {Promise<Object>} 增强分析结果
+   */
+  async getEnhancedCLIPattern(cliName) {
+    return await this.analyzeCLI(cliName, { enhanced: true });
+  }
+
+  /**
+   * Analyze call success and update patterns accordingly
+   */
+  async updatePatternOnAgentSkillFailure(cliName, error, attemptedCommand, userPrompt) {
+    if (process.env.DEBUG === 'true') {
+      console.log(`Updating agent/skill pattern for ${cliName} due to failure:`, error.message);
+    }
+
+    try {
+      // Re-analyze with enhanced capabilities
+      const newAnalysis = await this.analyzeCLIEnhanced(cliName);
+      
+      // Add failure context with agent/skill information
+      const detectedMentions = this.detectAgentSkillMentions(userPrompt, cliName);
+      newAnalysis.lastFailure = {
+        error: error.message,
+        attemptedCommand,
+        userPrompt,
+        agentSkillDetected: detectedMentions,
+        timestamp: new Date().toISOString(),
+      };
+
+      // Update the cached analysis
+      await this.cacheAnalysis(cliName, newAnalysis);
+      return newAnalysis;
+    } catch (analysisError) {
+      if (process.env.DEBUG === 'true') {
+        console.error(`Failed to re-analyze ${cliName}:`, analysisError.message);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Get agent/skill compatibility score for CLI tool
+   */
+  getAgentSkillCompatibilityScore(cliName, prompt) {
+    const enhancedPattern = this.enhancedPatterns[cliName];
+    if (!enhancedPattern) {
+      return { score: 0, reasons: ['CLI not supported'] };
+    }
+
+    const detectedMentions = this.detectAgentSkillMentions(prompt, cliName);
+    let score = 0.5; // Base score
+    const reasons = [];
+
+    // Base compatibility
+    if (enhancedPattern.agentDetection) {
+      score += 0.2;
+      reasons.push('支持智能体检测');
+    }
+    
+    if (enhancedPattern.skillDetection) {
+      score += 0.2;
+      reasons.push('支持技能检测');
+    }
+
+    // Detection results
+    if (detectedMentions.hasAgent) {
+      score += 0.1;
+      reasons.push('检测到智能体提及');
+    }
+
+    if (detectedMentions.hasSkill) {
+      score += 0.1;
+      reasons.push('检测到技能提及');
+    }
+
+    // CLI-specific advantages
+    if (cliName === 'qwen' && enhancedPattern.positionalArgs) {
+      score += 0.1;
+      reasons.push('位置参数支持，自然语言理解优秀');
+    }
+
+    if (cliName === 'codebuddy' && enhancedPattern.skillPrefixRequired) {
+      score += 0.1;
+      reasons.push('明确的技能语法支持');
+    }
+
+    // Penalty for mismatches
+    if (enhancedPattern.skillPrefixRequired && !detectedMentions.hasSkill) {
+      score -= 0.2;
+      reasons.push('需要技能语法但未检测到技能');
+    }
+
+    return { 
+      score: Math.max(0, Math.min(1, score)), 
+      reasons,
+      detected: detectedMentions
+    };
+  }
+
+  /**
+   * Generate optimized call command for CLI tool
+   */
+  generateOptimizedCall(cliName, userPrompt) {
+    const enhancedPattern = this.enhancedPatterns[cliName];
+    if (!enhancedPattern) {
+      return null;
+    }
+
+    // Optimize the prompt
+    const detectedMentions = this.detectAgentSkillMentions(userPrompt, cliName);
+    const optimizedPrompt = this.optimizePromptForCLI(userPrompt, cliName, detectedMentions);
+
+    // Generate command based on CLI format
+    let command;
+    let args;
+
+    switch (cliName) {
+      case 'qwen':
+        // Qwen uses positional arguments
+        command = 'qwen';
+        args = [optimizedPrompt];
+        break;
+        
+      case 'codebuddy':
+        // Codebuddy requires -y flag and skill prefix
+        command = 'codebuddy';
+        args = ['-y', '-p', optimizedPrompt];
+        break;
+        
+      case 'claude':
+      case 'iflow':
+      case 'qodercli':
+        // These use -p flag
+        command = cliName;
+        args = ['-p', optimizedPrompt];
+        break;
+        
+      default:
+        command = cliName;
+        args = ['-p', optimizedPrompt];
+    }
+
+    return {
+      command,
+      args,
+      fullCommand: `${command} ${args.join(' ')}`,
+      optimizedPrompt,
+      detectedMentions,
+      compatibilityScore: this.getAgentSkillCompatibilityScore(cliName, userPrompt)
+    };
+  }
 }
 
 module.exports = CLIHelpAnalyzer;