stigmergy 1.2.13 → 1.3.1

package/src/core/installer.js

@@ -1,3 +1,4 @@
+const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs/promises');
 const os = require('os');
@@ -6,12 +7,16 @@ const inquirer = require('inquirer');
 const SmartRouter = require('./smart_router');
 const { errorHandler } = require('./error_handler');
 const MemoryManager = require('./memory_manager');
+const EnhancedCLIInstaller = require('./enhanced_cli_installer');
 
-class StigmergyInstaller {
-  constructor() {
+class StigmergyInstaller extends EnhancedCLIInstaller {
+  constructor(options = {}) {
+    super(options);
+    this.concurrency = options.concurrency || 6;
     this.router = new SmartRouter();
     this.memory = new MemoryManager();
     this.configDir = path.join(os.homedir(), '.stigmergy');
+    this.scanCache = new Map(); // 缓存扫描结果
   }
 
   async checkCLI(toolName) {
@@ -48,36 +53,38 @@ class StigmergyInstaller {
             codexPath.endsWith('/codex') ||
             codexPath.endsWith('\\codex')
           ) {
-            // Read the script to find the JS file path
-            const fsSync = require('fs');
-            const scriptContent = fsSync.readFileSync(codexPath, 'utf8');
-
-            // Look for JS file reference in the script
-            const jsFileMatch = scriptContent.match(
-              /(["'])(.*?codex\.js.*?)\1/,
-            );
-            if (jsFileMatch) {
-              const jsFilePath = jsFileMatch[2];
-              // Check if JS file exists and is not empty
-              if (fsSync.existsSync(jsFilePath)) {
-                const stats = fsSync.statSync(jsFilePath);
-                if (stats.size === 0) {
-                  console.log(
-                    '[DEBUG] Codex JS file is empty, marking as unavailable',
-                  );
-                  return false;
+            // Try to verify JS file, but don't fail if we can't
+            // The actual --version test below is more reliable
+            try {
+              const fsSync = require('fs');
+              const scriptContent = fsSync.readFileSync(codexPath, 'utf8');
+
+              // Look for JS file reference in the script
+              // Match node_modules/@openai/codex/bin/codex.js pattern
+              const jsFileMatch = scriptContent.match(/node_modules\/@openai\/codex\/bin\/codex\.js/);
+              if (jsFileMatch) {
+                // Construct actual path based on npm global directory
+                const npmGlobalDir = require('path').dirname(codexPath);
+                const jsFilePath = require('path').join(npmGlobalDir, jsFileMatch[0]);
+
+                if (fsSync.existsSync(jsFilePath)) {
+                  const stats = fsSync.statSync(jsFilePath);
+                  if (stats.size === 0) {
+                    console.log('[DEBUG] Codex JS file is empty, marking as unavailable');
+                    return false;
+                  }
+                  // File exists and has content - continue to version check
+                } else {
+                  console.log('[DEBUG] Codex JS file not found at expected path, will try version check');
                 }
-              } else {
-                console.log(
-                  '[DEBUG] Codex JS file does not exist, marking as unavailable',
-                );
-                return false;
               }
+            } catch (scriptError) {
+              console.log(`[DEBUG] Could not verify codex script: ${scriptError.message}`);
+              // Continue anyway - the version check below is more reliable
             }
           }
 
-          // If we got here, the codex command exists and seems valid
-          // Continue with normal checks below
+          // If we got here, the codex command exists - continue with normal checks below
         } else {
           // Codex command doesn't exist
           return false;
@@ -109,8 +116,9 @@ class StigmergyInstaller {
         };
 
         // Additional protection for codex
+        // Note: codex requires shell=true on Windows to work properly
         if (toolName === 'codex') {
-          testOptions.shell = false;
+          // Keep shell=true for codex (don't override)
           testOptions.windowsHide = true;
           testOptions.detached = false;
         }
@@ -132,6 +140,7 @@ class StigmergyInstaller {
     // Special handling for codex to avoid opening files
     if (toolName === 'codex') {
       // For codex, only try --help and --version with extra precautions
+      // Note: codex requires shell=true on Windows
       const codexChecks = [
         { args: ['--help'], expected: 0 },
         { args: ['--version'], expected: 0 },
@@ -143,7 +152,7 @@ class StigmergyInstaller {
             encoding: 'utf8',
             timeout: 10000,
             stdio: ['pipe', 'pipe', 'pipe'], // Ensure all IO is piped
-            shell: false, // Don't use shell to avoid extra window opening
+            shell: true, // Use shell for codex compatibility
             windowsHide: true, // Hide console window on Windows
             detached: false, // Don't detach process
           });
@@ -201,36 +210,60 @@ class StigmergyInstaller {
 
   async scanCLI() {
     console.log('[SCAN] Scanning for AI CLI tools...');
+    
+    // 检查缓存
+    const cacheKey = 'scan_results';
+    if (this.scanCache.has(cacheKey)) {
+      console.log('[SCAN] Using cached scan results');
+      return this.scanCache.get(cacheKey);
+    }
+
     const available = {};
     const missing = {};
+    const tools = Object.entries(this.router.tools);
+
+    // 并行扫描所有工具
+    const scanPromises = tools.map(async ([toolName, toolInfo]) => {
+      // Skip internal functions without install command
+      if (!toolInfo.install) {
+        return { toolName, status: 'skip' };
+      }
 
-    for (const [toolName, toolInfo] of Object.entries(this.router.tools)) {
       try {
-        console.log(`[SCAN] Checking ${toolInfo.name}...`);
         const isAvailable = await this.checkCLI(toolName);
-
-        if (isAvailable) {
-          console.log(`[OK] ${toolInfo.name} is available`);
-          available[toolName] = toolInfo;
-        } else {
-          console.log(`[MISSING] ${toolInfo.name} is not installed`);
-          missing[toolName] = toolInfo;
-        }
+        return { toolName, status: isAvailable ? 'available' : 'missing', toolInfo };
       } catch (error) {
         await errorHandler.logError(
           error,
           'WARN',
           `StigmergyInstaller.scanCLI.${toolName}`,
         );
-        console.log(
-          `[ERROR] Failed to check ${toolInfo.name}: ${error.message}`,
-        );
-        console.log(`[MISSING] ${toolInfo.name} is not installed`);
-        missing[toolName] = toolInfo;
+        return { toolName, status: 'missing', toolInfo };
+      }
+    });
+
+    const results = await Promise.all(scanPromises);
+
+    // 处理结果
+    for (const result of results) {
+      if (result.status === 'skip') {
+        continue;
+      }
+
+      if (result.status === 'available') {
+        console.log(`[OK] ${result.toolInfo.name} is available`);
+        available[result.toolName] = result.toolInfo;
+      } else {
+        console.log(`[MISSING] ${result.toolInfo.name} is not installed`);
+        missing[result.toolName] = result.toolInfo;
       }
     }
 
-    return { available, missing };
+    // 缓存结果
+    const scanResults = { available, missing };
+    this.scanCache.set(cacheKey, scanResults);
+
+    return scanResults;
   }
 
   /**
@@ -305,52 +338,56 @@ class StigmergyInstaller {
 
   /**
    * Install selected CLI tools
+   * 统一调用父类EnhancedCLIInstaller的实现
    */
   async installTools(selectedTools, missingTools) {
-    const chalk = require('chalk');
-    let successCount = 0;
-
-    for (const toolName of selectedTools) {
-      const toolInfo = missingTools[toolName];
-      if (!toolInfo) continue;
-
-      console.log(`\n[INSTALL] Installing ${toolInfo.name}...`);
-      console.log(chalk.yellow(`Command: ${toolInfo.install}`));
-
-      try {
-        // Parse the install command
-        const [command, ...args] = toolInfo.install.split(' ');
-
-        // Execute the installation command
-        const result = spawnSync(command, args, {
-          stdio: 'inherit',  // Show output in real-time
-          shell: true,       // Use shell for npm commands
-          encoding: 'utf-8'
-        });
-
-        if (result.status === 0) {
-          console.log(chalk.green(`[OK] Successfully installed ${toolInfo.name}`));
-          successCount++;
-        } else {
-          console.log(chalk.red(`[ERROR] Failed to install ${toolInfo.name}. Exit code: ${result.status}`));
-          // Continue with other tools
+    // 调用父类的增强安装功能
+    const result = await super.installTools(selectedTools, missingTools);
+
+    // 保留StigmergyInstaller的特有功能：生成cross-CLI hooks
+    if (result && result.successful > 0) {
+      console.log('\n[HOOKS] Generating cross-CLI integration hooks...');
+      for (const toolName of selectedTools) {
+        const toolInfo = missingTools[toolName];
+        if (toolInfo && this.results.installations[toolName]?.success) {
+          try {
+            await this.generateToolHook(toolName, toolInfo);
+          } catch (error) {
+            console.log(`[WARN] Failed to generate hook for ${toolName}: ${error.message}`);
+          }
         }
-      } catch (error) {
-        console.log(chalk.red(`[ERROR] Installation failed for ${toolInfo.name}: ${error.message}`));
-        // Continue with other tools
       }
     }
 
-    if (successCount > 0) {
-      console.log(chalk.green(`\n[INSTALL] Successfully installed ${successCount}/${selectedTools.length} tools`));
+    return result;
+  }
 
-      // Add a short delay to ensure installations are complete
-      await new Promise(resolve => setTimeout(resolve, 2000));
+  /**
+   * Generate hook for a specific CLI tool
+   * @param {string} toolName - Name of the CLI tool
+   * @param {Object} toolInfo - Tool information object
+   */
+  async generateToolHook(toolName, toolInfo) {
+    console.log(`[HOOK] Generating hook for ${toolName}...`);
 
-      return true;
-    } else {
-      console.log(chalk.red('[INSTALL] No tools were successfully installed'));
-      return false;
+    const HookDeploymentManager = require('./coordination/nodejs/HookDeploymentManager');
+    const hookManager = new HookDeploymentManager();
+
+    await hookManager.initialize();
+
+    try {
+      const deploySuccess = await hookManager.deployHooksForCLI(toolName);
+
+      if (deploySuccess) {
+        console.log(`[OK] Hook generated successfully for ${toolName}`);
+        return true;
+      } else {
+        console.log(`[WARN] Hook generation failed for ${toolName}`);
+        return false;
+      }
+    } catch (error) {
+      console.error(`[ERROR] Hook generation error for ${toolName}:`, error.message);
+      throw error;
     }
   }
 
@@ -359,43 +396,39 @@ class StigmergyInstaller {
    */
   async deployHooks(available) {
     console.log('\n[DEPLOY] Deploying cross-CLI integration hooks...');
+    console.log(chalk.blue(`[INFO] Using parallel deployment with concurrency: ${this.concurrency || 6}`));
 
     const HookDeploymentManager = require('./coordination/nodejs/HookDeploymentManager');
     const hookManager = new HookDeploymentManager();
     
     await hookManager.initialize();
 
+    const toolEntries = Object.entries(available);
     let successCount = 0;
-    let totalCount = Object.keys(available).length;
-
-    for (const [toolName, toolInfo] of Object.entries(available)) {
-      console.log(`\n[DEPLOY] Deploying hooks for ${toolInfo.name}...`);
+    let totalCount = toolEntries.length;
+    const concurrency = this.concurrency || 6;
 
+    const deployForTool = async ([toolName, toolInfo]) => {
+      const startTime = Date.now();
+      
       try {
         const fs = require('fs/promises');
         const path = require('path');
         
-        // Create hooks directory
         await fs.mkdir(toolInfo.hooksDir, { recursive: true });
-        console.log(`[OK] Created hooks directory: ${toolInfo.hooksDir}`);
-
-        // Create config directory
         const configDir = path.dirname(toolInfo.config);
         await fs.mkdir(configDir, { recursive: true });
-        console.log(`[OK] Created config directory: ${configDir}`);
 
-        // Use HookDeploymentManager to deploy Node.js hooks
         const deploySuccess = await hookManager.deployHooksForCLI(toolName);
         
         if (deploySuccess) {
-          console.log(`[OK] Node.js hooks deployed successfully for ${toolInfo.name}`);
+          await this.installToolIntegration(toolName, toolInfo);
+          const duration = Date.now() - startTime;
+          console.log(`[OK] ${toolInfo.name} deployed successfully (${duration}ms)`);
+          return { success: true, toolName, duration };
         }
 
-        // Run JavaScript-based installation for each tool
-        await this.installToolIntegration(toolName, toolInfo);
-        
-        console.log(`[OK] Hooks deployed successfully for ${toolInfo.name}`);
-        successCount++;
+        return { success: false, toolName, duration: Date.now() - startTime };
 
       } catch (error) {
         const { errorHandler } = require('./error_handler');
@@ -404,16 +437,28 @@ class StigmergyInstaller {
           'ERROR',
           `StigmergyInstaller.deployHooks.${toolName}`,
         );
-        console.log(
-          `[ERROR] Failed to deploy hooks for ${toolInfo.name}: ${error.message}`,
-        );
-        console.log('[INFO] Continuing with other tools...');
+        
+        const duration = Date.now() - startTime;
+        console.log(`[ERROR] Failed to deploy hooks for ${toolInfo.name}: ${error.message} (${duration}ms)`);
+        
+        return { success: false, toolName, duration, error: error.message };
       }
+    };
+
+    const results = [];
+    for (let i = 0; i < toolEntries.length; i += concurrency) {
+      const batch = toolEntries.slice(i, i + concurrency);
+      const batchResults = await Promise.all(batch.map(deployForTool));
+      results.push(...batchResults);
     }
 
-    console.log(
-      `\n[SUMMARY] Hook deployment completed: ${successCount}/${totalCount} tools successful`,
-    );
+    successCount = results.filter(r => r.success).length;
+    const totalDuration = Math.max(...results.map(r => r.duration));
+
+    console.log(`\n[SUMMARY] Hook deployment completed: ${successCount}/${totalCount} tools successful`);
+    console.log(chalk.blue(`[PERFORMANCE] Total deployment time: ${totalDuration}ms`));
+    console.log(chalk.blue(`[PERFORMANCE] Average per tool: ${Math.round(totalDuration / totalCount)}ms`));
+    
     return successCount > 0;
   }