stigmergy 1.2.13 → 1.3.1

package/src/core/coordination/nodejs/HookDeploymentManager.js

@@ -1,9 +1,13 @@
 // src/core/coordination/nodejs/HookDeploymentManager.js
+// 重构后的简洁版本 - 核心协调功能
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { spawn, spawnSync } = require('child_process');
 
+// Import specialized generators
+const { ResumeSessionGenerator, SkillsIntegrationGenerator, CLIAdapterGenerator } = require('./generators');
+
 class HookDeploymentManager {
   constructor() {
     this.deploymentDir = path.join(os.homedir(), '.stigmergy', 'hooks');
@@ -16,7 +20,16 @@ class HookDeploymentManager {
       'codebuddy',
       'codex',
       'copilot',
+      'kode',
+      'opencode',
+      'oh-my-opencode'
+      // Note: 'resumesession' is handled separately as a session recovery tool, not a regular CLI
     ];
+
+    // Initialize generators
+    this.resumeSessionGenerator = new ResumeSessionGenerator();
+    this.skillsIntegrationGenerator = new SkillsIntegrationGenerator();
+    this.cliAdapterGenerator = new CLIAdapterGenerator();
   }
 
   async initialize() {
@@ -36,6 +49,12 @@ class HookDeploymentManager {
   async deployHooksForCLI(cliName, options = {}) {
     console.log(`[HOOK_DEPLOYMENT] Deploying hooks for ${cliName}...`);
 
+    // Skip resumesession as it's a session recovery tool, not a regular CLI tool
+    if (cliName.toLowerCase() === 'resumesession') {
+      console.log(`[HOOK_DEPLOYMENT] Skipping hooks deployment for ${cliName} (session recovery tool)`);
+      return true;
+    }
+
     if (!this.supportedCLIs.includes(cliName.toLowerCase())) {
       throw new Error(`Unsupported CLI: ${cliName}`);
     }
@@ -47,7 +66,7 @@ class HookDeploymentManager {
         fs.mkdirSync(cliHookDir, { recursive: true });
       }
 
-      // Deploy Node.js specific hooks
+      // Deploy Node.js specific hooks and extensions
       await this.deployNodeJsHooks(cliName, cliHookDir, options);
 
       console.log(
@@ -66,466 +85,241 @@ class HookDeploymentManager {
   async deployNodeJsHooks(cliName, hookDir, options) {
     console.log(`[HOOK_DEPLOYMENT] Deploying Node.js hooks for ${cliName}...`);
 
-    // Create a basic hook template for Node.js
-    const hookTemplate = this.generateNodeJsHookTemplate(cliName);
-    const hookFilePath = path.join(hookDir, `${cliName}_nodejs_hook.js`);
-
-    fs.writeFileSync(hookFilePath, hookTemplate);
-    console.log(`[HOOK_DEPLOYMENT] Created Node.js hook: ${hookFilePath}`);
-
-    // Make the hook executable
-    try {
-      fs.chmodSync(hookFilePath, 0o755);
-      console.log(`[HOOK_DEPLOYMENT] Made hook executable: ${hookFilePath}`);
-    } catch (error) {
-      console.warn(
-        `[HOOK_DEPLOYMENT] Failed to make hook executable: ${error.message}`,
-      );
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
     }
 
-    // Create configuration file
-    const config = {
-      cli: cliName,
-      hookPath: hookFilePath,
-      deploymentTime: new Date().toISOString(),
-      version: '1.0.0-nodejs',
-    };
-
-    const configPath = path.join(hookDir, 'config.json');
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-    console.log(`[HOOK_DEPLOYMENT] Created hook configuration: ${configPath}`);
-  }
+    // Deploy ResumeSession extension
+    await this.deployResumeSessionExtension(cliName, hookDir);
 
-  generateNodeJsHookTemplate(cliName) {
-    return `#!/usr/bin/env node
-/**
- * Node.js Hook for ${cliName.toUpperCase()}
- * Auto-generated by Stigmergy CLI Hook Deployment Manager
- */
-const fs = require('fs');
-const path = require('path');
+    // Deploy Skills integration
+    await this.deploySkillsIntegration(cliName, hookDir);
 
-// Embed LanguagePatternManager directly to ensure availability in deployed hooks
-class LanguagePatternManager {
-  constructor() {
-    this.supportedLanguages = {
-      en: { name: 'English', direction: 'ltr' },
-      zh: { name: 'Chinese', direction: 'ltr' },
-      ja: { name: 'Japanese', direction: 'ltr' },
-      ko: { name: 'Korean', direction: 'ltr' },
-      de: { name: 'German', direction: 'ltr' },
-      fr: { name: 'French', direction: 'ltr' },
-      es: { name: 'Spanish', direction: 'ltr' },
-      it: { name: 'Italian', direction: 'ltr' },
-      pt: { name: 'Portuguese', direction: 'ltr' },
-      ru: { name: 'Russian', direction: 'ltr' },
-      ar: { name: 'Arabic', direction: 'rtl' },
-      tr: { name: 'Turkish', direction: 'ltr' }
-    };
+    // Deploy CLI adapter
+    await this.deployCLIAdapter(cliName, hookDir);
 
-    // Define language patterns directly in the hook
-    this.languagePatterns = {
-      // English patterns
-      en: [
-        { name: 'use_tool_for_task', regex: /(?:use|call|ask)\\s+(\\w+)\\s+(?:to|for)\\s+(.+)$/i },
-        { name: 'please_use_tool', regex: /(?:please\\s+)?(?:use|call|ask)\\s+(\\w+)\\s+(.+)$/i },
-        { name: 'tool_please_help', regex: /(\\w+)[,\\s]+(?:please\\s+)?(?:help\\s+me\\s+)?(.+)$/i }
-      ],
-      // Chinese patterns
-      zh: [
-        { name: 'qing_yong_gongneng_bang_wo', regex: /请用(\\w+)\\s*帮我(.+)$/i },
-        { name: 'diaoyong_lai', regex: /调用(\\w+)\\s*来(.+)$/i },
-        { name: 'yong_gongneng_bang_wo', regex: /用(\\w+)\\s*帮我(.+)$/i },
-        { name: 'tool_comma_task', regex: /(\\w+)，(.+)$/i },
-        { name: 'rang_gongneng', regex: /让(\\w+)\\s*(.+)$/i }
-      ],
-      // German patterns
-      de: [
-        { name: 'benutze_tool_um', regex: /benutze\\s+(\\w+)\\s+um\\s+(.+)$/i },
-        { name: 'verwende_tool_fur', regex: /verwende\\s+(\\w+)\\s+für\\s+(.+)$/i },
-        { name: 'rufe_tool_fur_an', regex: /rufe\\s+(\\w+)\\s+für\\s+(.+)\\s+an$/i }
-      ],
-      // French patterns
-      fr: [
-        { name: 'utilise_tool_pour', regex: /utilise\\s+(\\w+)\\s+pour\\s+(.+)$/i },
-        { name: 'emploie_tool_avec', regex: /emploie\\s+(\\w+)\\s+avec\\s+(.+)$/i },
-        { name: 'appelle_tool_pour', regex: /appelle\\s+(\\w+)\\s+pour\\s+(.+)$/i }
-      ],
-      // Spanish patterns
-      es: [
-        { name: 'usa_tool_para', regex: /usa\\s+(\\w+)\\s+para\\s+(.+)$/i },
-        { name: 'utiliza_tool_para', regex: /utiliza\\s+(\\w+)\\s+para\\s+(.+)$/i },
-        { name: 'llama_tool_para', regex: /llama\\s+(\\w+)\\s+para\\s+(.+)$/i }
-      ],
-      // Italian patterns
-      it: [
-        { name: 'usa_tool_per', regex: /usa\\s+(\\w+)\\s+per\\s+(.+)$/i },
-        { name: 'utilizza_tool_per', regex: /utilizza\\s+(\\w+)\\s+per\\s+(.+)$/i },
-        { name: 'chiedi_tool_per', regex: /chiedi\\s+(\\w+)\\s+per\\s+(.+)$/i }
-      ],
-      // Portuguese patterns
-      pt: [
-        { name: 'usa_tool_para_pt', regex: /usa\\s+(\\w+)\\s+para\\s+(.+)$/i },
-        { name: 'utiliza_tool_para_pt', regex: /utiliza\\s+(\\w+)\\s+para\\s+(.+)$/i },
-        { name: 'chama_tool_para', regex: /chama\\s+(\\w+)\\s+para\\s+(.+)$/i }
-      ],
-      // Russian patterns
-      ru: [
-        { name: 'ispolzuy_tool_chtoby', regex: /используй\\s+(\\w+)\\s+чтобы\\s+(.+)$/i },
-        { name: 'primeni_tool_dlya', regex: /примени\\s+(\\w+)\\s+для\\s+(.+)$/i },
-        { name: 'vysovyi_tool_dlya', regex: /вызови\\s+(\\w+)\\s+для\\s+(.+)$/i }
-      ],
-      // Arabic patterns
-      ar: [
-        { name: 'ista5dam_tool_liktabat', regex: /استخدم\\s+(\\w+)\\s+ل(?:كتابة|عمل)\\s+(.+)$/i },
-        { name: 'atssil_b_tool', regex: /اتصل\\s+ب\\s+(\\w+)\\s+(.+)$/i },
-        { name: 'ast5raj_tool', regex: /استخرج\\s+(\\w+)\\s+(.+)$/i }
-      ],
-      // Japanese patterns
-      ja: [
-        { name: 'tool_o_tsukatte', regex: /(\\w+)\\s*を使って\\s*(.+)$/i },
-        { name: 'tool_wo_yatte', regex: /(\\w+)\\s*を\\s*やって\\s*(.+)$/i },
-        { name: 'tool_ni_onegaishimasu', regex: /(\\w+)、\\s*(.+)$/i }
-      ],
-      // Korean patterns
-      ko: [
-        { name: 'tool_sayonghae', regex: /(\\w+)\\s*를\\s*사용해\\s*(.+)$/i },
-        { name: 'tool_sayonghayeyo', regex: /(\\w+)\\s*를\\s*사용하여\\s*(.+)$/i },
-        { name: 'tool_irae', regex: /(\\w+)\\s*을\\s*이용해\\s*(.+)$/i },
-        { name: 'tool_ggumyeon', regex: /(\\w+)\\s*하고\\s*(.+)$/i }
-      ],
-      // Turkish patterns
-      tr: [
-        { name: 'tool_icin_kullan', regex: /(\\w+)'?u\\s*(.+)\\s+için\\s+kullan/i },
-        { name: 'tool_kullan_icin', regex: /(\\w+)\\s*kullan\\s+için\\s*(.+)$/i },
-        { name: 'tool_ile_yap', regex: /(\\w+)\\s*ile\\s*(.+)$/i }
-      ]
-    };
-  }
-
-  getPatterns(languageCode) {
-    return this.languagePatterns[languageCode] || [];
-  }
-
-  getAllPatterns() {
-    return this.languagePatterns;
+    // Create basic configuration
+    await this.createBasicConfiguration(cliName, hookDir);
   }
 
-  detectLanguage() {
-    // Try to detect language from environment variables
-    const envLang = process.env.LANG || process.env.LANGUAGE || process.env.LC_ALL || process.env.LC_MESSAGES;
+  async deployResumeSessionExtension(cliName, hookDir) {
+    console.log(`[HOOK_DEPLOYMENT] Deploying ResumeSession extension for ${cliName}...`);
 
-    if (envLang) {
-      // Extract language code (e.g., en_US.UTF-8 -> en)
-      const langCode = envLang.split('.')[0].split('_')[0].split('-')[0].toLowerCase();
-      if (this.supportedLanguages[langCode]) {
-        return langCode;
-      }
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
     }
 
-    // Try to detect language using Intl API
     try {
-      if (typeof Intl !== 'undefined' && Intl.DateTimeFormat) {
-        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
-        if (locale) {
-          const langCode = locale.split('-')[0].toLowerCase();
-          if (this.supportedLanguages[langCode]) {
-            return langCode;
-          }
-        }
-      }
-    } catch (error) {
-      // Intl API not available or failed
-    }
-
-    // Default to English
-    return 'en';
-  }
+      const extensionContent = this.resumeSessionGenerator.generateForCLI(cliName);
+      const fileName = this.resumeSessionGenerator.getFileName(cliName);
+      const extensionPath = path.join(hookDir, fileName);
 
-  detectCrossCLIRequest(input, preferredLanguage = null) {
-    // If preferred language is specified, try that first
-    if (preferredLanguage && this.languagePatterns[preferredLanguage]) {
-      const result = this.matchPatterns(input, preferredLanguage);
-      if (result) return result;
-    }
+      fs.writeFileSync(extensionPath, extensionContent);
+      console.log(`[HOOK_DEPLOYMENT] Created ResumeSession extension: ${extensionPath}`);
 
-    // Try user's detected language
-    const detectedLanguage = this.detectLanguage();
-    if (detectedLanguage !== preferredLanguage) {
-      const result = this.matchPatterns(input, detectedLanguage);
-      if (result) return result;
-    }
+      // Make the extension executable
+      try {
+        fs.chmodSync(extensionPath, 0o755);
+        console.log(`[HOOK_DEPLOYMENT] Made extension executable: ${extensionPath}`);
+      } catch (error) {
+        console.warn(
+          `[HOOK_DEPLOYMENT] Failed to make extension executable: ${error.message}`,
+        );
+      }
 
-    // Fall back to English
-    if (detectedLanguage !== 'en') {
-      const result = this.matchPatterns(input, 'en');
-      if (result) return result;
-    }
+      // Create or update hooks.json to register the stigmergy-resume command
+      await this.updateHooksJson(cliName, hookDir, fileName);
 
-    // Try all languages as last resort
-    for (const languageCode in this.languagePatterns) {
-      if (languageCode !== detectedLanguage && languageCode !== 'en') {
-        const result = this.matchPatterns(input, languageCode);
-        if (result) return result;
-      }
+      return true;
+    } catch (error) {
+      console.error(`[HOOK_DEPLOYMENT] Failed to deploy ResumeSession extension for ${cliName}:`, error);
+      return false;
     }
-
-    return null;
   }
 
-  matchPatterns(input, languageCode) {
-    const patterns = this.languagePatterns[languageCode];
-    if (!patterns) return null;
-
-    for (const pattern of patterns) {
-      const match = input.match(pattern.regex);
-      if (match && match.length >= 3) {
-        const targetCLI = match[1].toLowerCase();
-        const task = match[2];
-
-        // Validate that the target CLI is supported
-        const supportedCLIs = [
-          'claude', 'gemini', 'qwen', 'iflow', 'qodercli', 'codebuddy', 'codex', 'copilot'
-        ];
-
-        if (supportedCLIs.includes(targetCLI)) {
-          return {
-            targetCLI: targetCLI,
-            task: task,
-            language: languageCode,
-            patternName: pattern.name
-          };
-        }
+  async updateHooksJson(cliName, hookDir, resumeSessionFileName) {
+    const hooksJsonPath = path.join(hookDir, 'hooks.json');
+    let hooksConfig = {};
+
+    // Load existing hooks.json if it exists
+    if (fs.existsSync(hooksJsonPath)) {
+      try {
+        const existingContent = fs.readFileSync(hooksJsonPath, 'utf8');
+        hooksConfig = JSON.parse(existingContent);
+      } catch (error) {
+        console.warn(`[HOOK_DEPLOYMENT] Failed to parse existing hooks.json, creating new one: ${error.message}`);
+        hooksConfig = {};
       }
     }
 
-    return null;
+    // Register the stigmergy-resume command
+    hooksConfig.resumesession = {
+      enabled: true,
+      command: '/stigmergy-resume',
+      handler: resumeSessionFileName,
+      description: 'Resume or query session history across CLIs',
+      version: '1.0.4',
+      deploymentTime: new Date().toISOString()
+    };
+
+    // Write the updated hooks.json
+    fs.writeFileSync(hooksJsonPath, JSON.stringify(hooksConfig, null, 2));
+    console.log(`[HOOK_DEPLOYMENT] Updated hooks.json with resumesession command: ${hooksJsonPath}`);
   }
-}
 
-// Instantiate the LanguagePatternManager
-const embeddedLanguageManager = new LanguagePatternManager();
+  async deploySkillsIntegration(cliName, hookDir) {
+    console.log(`[HOOK_DEPLOYMENT] Deploying skills integration for ${cliName}...`);
 
-class ${this.capitalize(cliName)}NodeJsHook {
-  constructor() {
-    this.cliName = '${cliName}';
-    this.hookDir = __dirname;
-    this.logFile = path.join(this.hookDir, '${cliName}_hook.log');
-    this.languageManager = embeddedLanguageManager;
-  }
-  async onUserPrompt(prompt, context) {
-    this.log('INFO', \`User prompt received: \${prompt}\`);
-    // Check for cross-CLI requests
-    const crossCLIRequest = this.detectCrossCLIRequest(prompt);
-    if (crossCLIRequest) {
-      return await this.handleCrossCLIRequest(crossCLIRequest, context);
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
     }
-    // Default processing
-    return null;
-  }
-  async onToolUse(toolName, toolArgs, context) {
-    this.log('INFO', \`Tool use detected: \${toolName}\`);
-    return null;
-  }
-  async onResponseGenerated(response, context) {
-    this.log('INFO', 'Response generated');
-    return null;
-  }
-  detectCrossCLIRequest(prompt) {
-    // Use the embedded LanguagePatternManager for enhanced multilingual pattern matching
+
     try {
-      // Verify that the languageManager has the required method
-      if (this.languageManager && this.languageManager.detectCrossCLIRequest) {
-        const result = this.languageManager.detectCrossCLIRequest(prompt);
-
-        if (result) {
-          return {
-            targetCLI: result.targetCLI,
-            task: result.task,
-            source: this.cliName,
-            language: result.language,
-            patternName: result.patternName
-          };
-        }
+      const skillsResult = this.skillsIntegrationGenerator.generateForCLI(cliName);
+      const skillsPath = path.join(hookDir, skillsResult.fileName);
+
+      fs.writeFileSync(skillsPath, skillsResult.content);
+      console.log(`[HOOK_DEPLOYMENT] Created skills integration: ${skillsPath}`);
+
+      // Make the skills file executable
+      try {
+        fs.chmodSync(skillsPath, 0o755);
+        console.log(`[HOOK_DEPLOYMENT] Made skills integration executable: ${skillsPath}`);
+      } catch (error) {
+        console.warn(`[HOOK_DEPLOYMENT] Failed to make skills integration executable: ${error.message}`);
       }
-    } catch (error) {
-      // If LanguagePatternManager fails, fall back to original pattern matching
-      console.warn('LanguagePatternManager failed, falling back to original patterns:', error.message);
-    }
 
-    // Fallback to original pattern matching for backward compatibility
-    const patterns = [
-      /(?:use|call|ask)\\s+(\\w+)\\s+(?:to|for)\\s+(.+)$/i,
-      /(?:please\\s+)?(?:use|call|ask)\\s+(\\w+)\\s+(.+)$/i,
-      /(\\w+)[,\\s]+((?:please\\s+)?(?:help\\s+me\\s+)?(?:.+))$/i,
-      /请用(\\w+)\\s*帮我(.+)$/i,
-      /调用(\\w+)\\s*来(.+)$/i,
-      /用(\\w+)\\s*帮我(.+)$/i,
-      /(\\w+)，(.+)$/i,
-      /让(\\w+)\\s*(.+)$/i,
-      /(?:utiliser|appeler|demander)\\s+(\\w+)\\s+(?:pour|afin de)\\s+(.+)$/i,
-      /(?:usar|llamar|pedir)\\s+(\\w+)\\s+(?:para|para que)\\s+(.+)$/i,
-      /(?:utilizzare|chiedere)\\s+(\\w+)\\s+(?:per|per far)\\s+(.+)$/i,
-      /(?:verwenden|aufrufen|bitten)\\s+(\\w+)\\s+(?:für|um)\\s+(.+)$/i,
-      /(?:使う|呼び出す|頼む)\\s+(\\w+)\\s+(?:ために|で)\\s+(.+)$/i
-    ];
+      // Create skills configuration
+      const skillsConfig = {
+        cli: cliName,
+        skillsPath: skillsPath,
+        skillsDirectory: path.join(os.homedir(), '.stigmergy', 'skills'),
+        deploymentTime: new Date().toISOString(),
+        version: '1.0.0-skills'
+      };
 
-    for (const pattern of patterns) {
-      const match = prompt.match(pattern);
-      if (match && match.length >= 3) {
-        const targetCLI = match[1].toLowerCase();
-        let task = match[2];
-
-        // For the specific pattern that includes optional prefixes in the task capture,
-        // no additional processing needed as it's already captured correctly
-        if (pattern.source.includes('(?:please\\\\s+)?(?:help\\\\s+me\\\\s+)?')) {
-          // This is the pattern /(\\w+)[,\\\\s]+((?:please\\\\s+)?(?:help\\\\s+me\\\\s+)?(?:.+))$/i
-          // The task is already captured with the prefixes if they exist
-        }
+      const configPath = path.join(hookDir, 'skills-config.json');
+      fs.writeFileSync(configPath, JSON.stringify(skillsConfig, null, 2));
+      console.log(`[HOOK_DEPLOYMENT] Created skills configuration: ${configPath}`);
 
-        // Validate that the target CLI is supported
-        const supportedCLIs = [
-          'claude', 'gemini', 'qwen', 'iflow', 'qodercli', 'codebuddy', 'codex', 'copilot'
-        ];
-
-        if (supportedCLIs.includes(targetCLI)) {
-          return {
-            targetCLI: targetCLI,
-            task: task,
-            source: this.cliName
-          };
-        }
-      }
+      return true;
+    } catch (error) {
+      console.error(`[HOOK_DEPLOYMENT] Failed to deploy skills integration for ${cliName}:`, error);
+      return false;
     }
-
-    return null;
   }
-  async handleCrossCLIRequest(request, context) {
-    this.log('INFO', \`Cross-CLI request detected: \${JSON.stringify(request)}\`);
 
-    // Validate the request
-    if (!request.targetCLI || !request.task) {
-      this.log('ERROR', 'Invalid cross-CLI request: missing targetCLI or task');
-      return \`[CROSS-CLI] Invalid request: missing targetCLI or task\`;
-    }
+  async deployCLIAdapter(cliName, hookDir) {
+    console.log(`[HOOK_DEPLOYMENT] Deploying CLI adapter for ${cliName}...`);
 
-    // Check if the target CLI is the same as the source
-    if (request.targetCLI === this.cliName) {
-      this.log('WARN', 'Cross-CLI request to self ignored');
-      return \`[CROSS-CLI] Cannot call self (\${request.targetCLI})\`;
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
     }
 
-    // Communicate with the coordination layer to execute the cross-CLI call
     try {
-      // Try to load the CLCommunication module
-      let CLCommunication;
-      try {
-        // First, try the standard installation path
-        const modulePath = path.join(__dirname, '..', '..', '..', 'node_modules', 'stigmergy', 'src', 'core', 'coordination', 'nodejs', 'CLCommunication');
-        CLCommunication = require(modulePath);
-      } catch (e) {
-        // If that fails, try alternative paths or gracefully degrade
-        console.warn('CLCommunication module not found, cross-CLI functionality may be limited');
-        return \`[CROSS-CLI] CLCommunication module not found for \${request.targetCLI}\`;
-      }
+      const adapterContent = this.cliAdapterGenerator.generateForCLI(cliName);
+      const fileName = this.cliAdapterGenerator.getFileName(cliName);
+      const adapterPath = path.join(hookDir, fileName);
 
-      const communicator = new CLCommunication();
+      fs.writeFileSync(adapterPath, adapterContent);
+      console.log(`[HOOK_DEPLOYMENT] Created CLI adapter: ${adapterPath}`);
 
-      const result = await communicator.executeTask(
-        request.source,
-        request.targetCLI,
-        request.task,
-        context
-      );
-
-      if (result.success) {
-        return \`[CROSS-CLI] Response from \${request.targetCLI}: \${result.output}\`;
-      } else {
-        return \`[CROSS-CLI] Error from \${request.targetCLI}: \${result.error}\`;
+      // Make the adapter executable
+      try {
+        fs.chmodSync(adapterPath, 0o755);
+        console.log(`[HOOK_DEPLOYMENT] Made adapter executable: ${adapterPath}`);
+      } catch (error) {
+        console.warn(`[HOOK_DEPLOYMENT] Failed to make adapter executable: ${error.message}`);
       }
+
+      return true;
     } catch (error) {
-      this.log('ERROR', \`Failed to handle cross-CLI request: \${error.message}\`);
-      return \`[CROSS-CLI] Failed to execute \${request.targetCLI}: \${error.message}\`;
+      console.error(`[HOOK_DEPLOYMENT] Failed to deploy CLI adapter for ${cliName}:`, error);
+      return false;
     }
   }
-  log(level, message) {
-    const timestamp = new Date().toISOString();
-    const logEntry = \`[\${timestamp}] [\${level}] [\${this.cliName.toUpperCase()}] \${message}\\n\`;
 
-    try {
-      fs.appendFileSync(this.logFile, logEntry);
-    } catch (error) {
-      console.error('Failed to write to log file:', error);
+  async createBasicConfiguration(cliName, hookDir) {
+    console.log(`[HOOK_DEPLOYMENT] Creating basic configuration for ${cliName}...`);
+
+    // Ensure hook directory exists
+    if (!fs.existsSync(hookDir)) {
+      fs.mkdirSync(hookDir, { recursive: true });
     }
-  }
-  capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-}
 
-// Export the hook class
-module.exports = ${this.capitalize(cliName)}NodeJsHook;
+    try {
+      // Create main configuration file
+      const config = {
+        cli: cliName,
+        hookPath: hookDir,
+        deploymentTime: new Date().toISOString(),
+        version: '1.0.0-nodejs',
+        modules: {
+          resumeSession: true,
+          skillsIntegration: true,
+          cliAdapter: true
+        }
+      };
 
-// If run directly, instantiate and test
-if (require.main === module) {
-  const hook = new ${this.capitalize(cliName)}NodeJsHook();
-  console.log('${cliName.toUpperCase()} Node.js Hook initialized');
-}`;
-  }
+      const configPath = path.join(hookDir, 'config.json');
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(`[HOOK_DEPLOYMENT] Created configuration: ${configPath}`);
 
-  capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
+      return true;
+    } catch (error) {
+      console.error(`[HOOK_DEPLOYMENT] Failed to create configuration for ${cliName}:`, error);
+      return false;
+    }
   }
 
-  async undeployHooksForCLI(cliName) {
-    console.log(`[HOOK_DEPLOYMENT] Undeploying hooks for ${cliName}...`);
+  async deployHooksForAllCLIs(options = {}) {
+    console.log('[HOOK_DEPLOYMENT] Deploying hooks for all supported CLIs...');
 
-    const cliHookDir = path.join(this.deploymentDir, cliName);
-    if (fs.existsSync(cliHookDir)) {
-      try {
-        fs.rmSync(cliHookDir, { recursive: true, force: true });
-        console.log(`[HOOK_DEPLOYMENT] Removed hook directory: ${cliHookDir}`);
-        return true;
-      } catch (error) {
-        console.error(
-          '[HOOK_DEPLOYMENT] Failed to remove hook directory:',
-          error,
-        );
-        return false;
-      }
+    const results = [];
+    for (const cliName of this.supportedCLIs) {
+      const success = await this.deployHooksForCLI(cliName, options);
+      results.push({ cli: cliName, success });
     }
 
-    console.log(`[HOOK_DEPLOYMENT] No hooks found for ${cliName}`);
-    return true;
-  }
+    const successful = results.filter(r => r.success).length;
+    console.log(
+      `[HOOK_DEPLOYMENT] Deployment complete: ${successful}/${this.supportedCLIs.length} CLIs configured`,
+    );
 
-  async listDeployedHooks() {
-    if (!fs.existsSync(this.deploymentDir)) {
-      return [];
-    }
+    return results;
+  }
 
-    const cliDirs = fs
-      .readdirSync(this.deploymentDir, { withFileTypes: true })
-      .filter((dirent) => dirent.isDirectory())
-      .map((dirent) => dirent.name);
-
-    const hooks = [];
-    for (const cliName of cliDirs) {
-      const configPath = path.join(this.deploymentDir, cliName, 'config.json');
-      if (fs.existsSync(configPath)) {
-        try {
-          const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-          hooks.push(config);
-        } catch (error) {
-          console.warn(
-            `[HOOK_DEPLOYMENT] Failed to read config for ${cliName}:`,
-            error.message,
-          );
+  async getDeployedHooks() {
+    try {
+      const cliDirs = fs.readdirSync(this.deploymentDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+
+      const hooks = [];
+      for (const cliName of cliDirs) {
+        const configPath = path.join(this.deploymentDir, cliName, 'config.json');
+        if (fs.existsSync(configPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            hooks.push(config);
+          } catch (error) {
+            console.warn(
+              `[HOOK_DEPLOYMENT] Failed to read config for ${cliName}:`,
+              error.message,
+            );
+          }
         }
       }
-    }
 
-    return hooks;
+      return hooks;
+    } catch (error) {
+      console.error('[HOOK_DEPLOYMENT] Failed to get deployed hooks:', error);
+      return [];
+    }
   }
 
   async validateHookDeployment(cliName) {
@@ -543,18 +337,54 @@ if (require.main === module) {
       return { valid: false, error: 'Configuration file not found' };
     }
 
-    const hookPath = path.join(cliHookDir, `${cliName}_nodejs_hook.js`);
-    if (!fs.existsSync(hookPath)) {
-      return { valid: false, error: 'Hook script not found' };
-    }
-
-    // Try to load the hook
     try {
-      require(hookPath);
-      return { valid: true, message: 'Hook deployment is valid' };
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+      // Validate that all expected modules are present
+      const expectedModules = ['resumeSession', 'skillsIntegration', 'cliAdapter'];
+      if (!config.modules) {
+        return { valid: false, error: 'Module configuration not found' };
+      }
+
+      for (const module of expectedModules) {
+        if (!config.modules[module]) {
+          return { valid: false, error: `Module ${module} not configured` };
+        }
+      }
+
+      return {
+        valid: true,
+        message: 'Hook deployment is valid',
+        modules: config.modules
+      };
     } catch (error) {
-      return { valid: false, error: `Failed to load hook: ${error.message}` };
+      return { valid: false, error: `Failed to validate deployment: ${error.message}` };
+    }
+  }
+
+  async validateAllDeployments() {
+    console.log('[HOOK_DEPLOYMENT] Validating all hook deployments...');
+
+    const results = [];
+    for (const cliName of this.supportedCLIs) {
+      const validation = await this.validateHookDeployment(cliName);
+      results.push({ cli: cliName, ...validation });
     }
+
+    const valid = results.filter(r => r.valid).length;
+    console.log(
+      `[HOOK_DEPLOYMENT] Validation complete: ${valid}/${this.supportedCLIs.length} deployments valid`,
+    );
+
+    return results;
+  }
+
+  getDeploymentStatus() {
+    return {
+      deploymentDir: this.deploymentDir,
+      supportedCLIs: this.supportedCLIs,
+      initialized: fs.existsSync(this.deploymentDir)
+    };
   }
 }