stigmergy 1.0.99 → 1.1.0

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

@@ -0,0 +1,236 @@
+// src/core/coordination/nodejs/CLIIntegrationManager.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, spawnSync } = require('child_process');
+
+class CLIIntegrationManager {
+  constructor() {
+    this.supportedCLIs = {
+      'claude': {
+        name: 'Claude CLI',
+        executable: 'claude',
+        hooks: ['user_prompt_submit', 'tool_use_pre', 'tool_use_post', 'response_generated']
+      },
+      'gemini': {
+        name: 'Gemini CLI',
+        executable: 'gemini',
+        extensions: ['on_user_input', 'on_response_generated', 'on_tool_execution']
+      },
+      'qwencode': {
+        name: 'QwenCode CLI',
+        executable: 'qwencode',
+        inheritance: ['on_code_generation', 'on_analysis_request', 'on_refactor_request']
+      },
+      'iflow': {
+        name: 'iFlow CLI',
+        executable: 'iflow',
+        workflows: ['on_workflow_start', 'on_stage_complete', 'on_workflow_success']
+      },
+      'qoder': {
+        name: 'Qoder CLI',
+        executable: 'qoder',
+        notifications: ['on_user_notification', 'on_system_alert', 'on_task_completion']
+      },
+      'codebuddy': {
+        name: 'CodeBuddy CLI',
+        executable: 'codebuddy',
+        skills: ['on_skill_invocation', 'on_buddy_request', 'on_cross_cli_task']
+      },
+      'codex': {
+        name: 'Codex CLI',
+        executable: 'codex',
+        slashCommands: ['/x', '/cross-cli', '/delegate']
+      },
+      'copilot': {
+        name: 'Copilot CLI',
+        executable: 'copilot',
+        mcp: ['cross_cli_execute']
+      }
+    };
+  }
+
+  async checkCLIAvailability(cliName) {
+    console.log(`[CLI_INTEGRATION] Checking availability of ${cliName}...`);
+    
+    const cliInfo = this.supportedCLIs[cliName.toLowerCase()];
+    if (!cliInfo) {
+      return { available: false, error: `Unsupported CLI: ${cliName}` };
+    }
+
+    try {
+      // Check if CLI executable is available
+      const result = spawnSync(cliInfo.executable, ['--version'], {
+        timeout: 5000,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      if (result.status === 0) {
+        const version = result.stdout ? result.stdout.toString().trim() : 'Unknown';
+        return {
+          available: true,
+          version: version,
+          name: cliInfo.name
+        };
+      } else {
+        return {
+          available: false,
+          error: `CLI returned non-zero exit code: ${result.status}`,
+          stderr: result.stderr ? result.stderr.toString() : ''
+        };
+      }
+    } catch (error) {
+      return {
+        available: false,
+        error: `Failed to execute CLI: ${error.message}`
+      };
+    }
+  }
+
+  async listAvailableCLIs() {
+    console.log('[CLI_INTEGRATION] Listing available CLIs...');
+    
+    const results = {};
+    for (const [cliName, cliInfo] of Object.entries(this.supportedCLIs)) {
+      results[cliName] = await this.checkCLIAvailability(cliName);
+    }
+    
+    return results;
+  }
+
+  async getNodeJsIntegrationScript(cliName) {
+    console.log(`[CLI_INTEGRATION] Generating Node.js integration script for ${cliName}...`);
+    
+    const cliInfo = this.supportedCLIs[cliName.toLowerCase()];
+    if (!cliInfo) {
+      throw new Error(`Unsupported CLI: ${cliName}`);
+    }
+
+    // Generate a Node.js integration script
+    const script = `#!/usr/bin/env node
+
+/**
+ * Node.js Integration Script for ${cliInfo.name}
+ * Auto-generated by Stigmergy CLI Integration Manager
+ */
+
+const { spawn } = require('child_process');
+
+class ${this.capitalize(cliName)}NodeJsIntegration {
+  constructor() {
+    this.cliName = '${cliName}';
+    this.executable = '${cliInfo.executable}';
+  }
+
+  async executeCommand(command, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+      const cliProcess = spawn(this.executable, [command, ...args], {
+        timeout: options.timeout || 30000,
+        ...options
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      cliProcess.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      cliProcess.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      cliProcess.on('close', (code) => {
+        if (code === 0) {
+          resolve(stdout.trim());
+        } else {
+          reject(new Error(\`CLI process exited with code \${code}: \${stderr}\`));
+        }
+      });
+
+      cliProcess.on('error', (error) => {
+        reject(new Error(\`Failed to start CLI process: \${error.message}\`));
+      });
+    });
+  }
+
+  async getVersion() {
+    try {
+      const version = await this.executeCommand('--version');
+      return version;
+    } catch (error) {
+      throw new Error(\`Failed to get ${cliName} version: \${error.message}\`);
+    }
+  }
+
+  async executeTask(task, context = {}) {
+    // This would depend on the specific CLI's interface
+    // For demonstration, we'll simulate execution
+    return \`[NODE.JS INTEGRATION] Simulated execution of task: \${task}\`;
+  }
+
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+}
+
+module.exports = ${this.capitalize(cliName)}NodeJsIntegration;
+
+// If run directly, test the integration
+if (require.main === module) {
+  const integration = new ${this.capitalize(cliName)}NodeJsIntegration();
+  
+  integration.getVersion()
+    .then(version => {
+      console.log('${cliInfo.name} version:', version);
+    })
+    .catch(error => {
+      console.error('Failed to get version:', error.message);
+    });
+}
+`;
+
+    return script;
+  }
+
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  async deployNodeJsIntegration(cliName, targetDir) {
+    console.log(`[CLI_INTEGRATION] Deploying Node.js integration for ${cliName}...`);
+    
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    const script = await this.getNodeJsIntegrationScript(cliName);
+    const scriptPath = path.join(targetDir, `${cliName}_nodejs_integration.js`);
+    
+    fs.writeFileSync(scriptPath, script);
+    
+    // Make executable
+    try {
+      fs.chmodSync(scriptPath, 0o755);
+    } catch (error) {
+      console.warn(`[CLI_INTEGRATION] Failed to make script executable:`, error.message);
+    }
+    
+    return scriptPath;
+  }
+
+  async getSupportedFeatures(cliName) {
+    const cliInfo = this.supportedCLIs[cliName.toLowerCase()];
+    if (!cliInfo) {
+      return null;
+    }
+    
+    return {
+      name: cliInfo.name,
+      executable: cliInfo.executable,
+      features: Object.keys(cliInfo).filter(key => key !== 'name' && key !== 'executable')
+    };
+  }
+}
+
+module.exports = CLIIntegrationManager;

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

@@ -0,0 +1,77 @@
+// src/core/coordination/nodejs/HealthChecker.js
+const os = require('os');
+
+class HealthChecker {
+  constructor() {
+    this.checks = [
+      'AdapterAvailability',
+      'SystemResources',
+      'DiskSpace'
+    ];
+  }
+
+  async checkHealth() {
+    console.log('[HEALTH_CHECKER] Performing health check...');
+    
+    const results = {};
+    let overallHealthy = true;
+
+    for (const check of this.checks) {
+      try {
+        const methodName = `check${check}`;
+        if (typeof this[methodName] === 'function') {
+          results[check.toLowerCase()] = await this[methodName]();
+        } else {
+          results[check.toLowerCase()] = { healthy: false, error: `Method ${methodName} not found` };
+          overallHealthy = false;
+        }
+      } catch (error) {
+        results[check.toLowerCase()] = { healthy: false, error: error.message };
+        overallHealthy = false;
+      }
+    }
+
+    return {
+      healthy: overallHealthy,
+      timestamp: new Date().toISOString(),
+      checks: results
+    };
+  }
+
+  async checkAdapterAvailability() {
+    // In a real implementation, this would check actual adapter availability
+    return {
+      healthy: true,
+      unavailableAdapters: []
+    };
+  }
+
+  async checkSystemResources() {
+    const memUsage = process.memoryUsage();
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMemPercent = ((totalMem - freeMem) / totalMem) * 100;
+    
+    return {
+      healthy: usedMemPercent < 90, // Healthy if less than 90% memory used
+      memory: {
+        used: totalMem - freeMem,
+        free: freeMem,
+        total: totalMem,
+        percent: usedMemPercent
+      },
+      cpu: os.cpus().length
+    };
+  }
+
+  async checkDiskSpace() {
+    // Node.js doesn't have built-in disk space checking
+    // This is a simplified check
+    return {
+      healthy: true,
+      message: 'Disk space check not implemented in Node.js layer'
+    };
+  }
+}
+
+module.exports = HealthChecker;

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

@@ -0,0 +1,256 @@
+// src/core/coordination/nodejs/HookDeploymentManager.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, spawnSync } = require('child_process');
+
+class HookDeploymentManager {
+  constructor() {
+    this.deploymentDir = path.join(os.homedir(), '.stigmergy', 'hooks');
+    this.supportedCLIs = [
+      'claude', 'gemini', 'qwencode', 'iflow', 'qoder', 'codebuddy', 'codex', 'copilot'
+    ];
+  }
+
+  async initialize() {
+    console.log('[HOOK_DEPLOYMENT] Initializing hook deployment manager...');
+    await this.ensureDeploymentDirectory();
+  }
+
+  async ensureDeploymentDirectory() {
+    if (!fs.existsSync(this.deploymentDir)) {
+      fs.mkdirSync(this.deploymentDir, { recursive: true });
+      console.log(`[HOOK_DEPLOYMENT] Created deployment directory: ${this.deploymentDir}`);
+    }
+  }
+
+  async deployHooksForCLI(cliName, options = {}) {
+    console.log(`[HOOK_DEPLOYMENT] Deploying hooks for ${cliName}...`);
+    
+    if (!this.supportedCLIs.includes(cliName.toLowerCase())) {
+      throw new Error(`Unsupported CLI: ${cliName}`);
+    }
+
+    try {
+      // Create CLI-specific hook directory
+      const cliHookDir = path.join(this.deploymentDir, cliName);
+      if (!fs.existsSync(cliHookDir)) {
+        fs.mkdirSync(cliHookDir, { recursive: true });
+      }
+
+      // Deploy Node.js specific hooks
+      await this.deployNodeJsHooks(cliName, cliHookDir, options);
+      
+      console.log(`[HOOK_DEPLOYMENT] Hooks deployed successfully for ${cliName}`);
+      return true;
+    } catch (error) {
+      console.error(`[HOOK_DEPLOYMENT] Failed to deploy hooks for ${cliName}:`, error);
+      return false;
+    }
+  }
+
+  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}`);
+    }
+    
+    // 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}`);
+  }
+
+  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');
+
+class ${this.capitalize(cliName)}NodeJsHook {
+  constructor() {
+    this.cliName = '${cliName}';
+    this.hookDir = __dirname;
+    this.logFile = path.join(this.hookDir, '${cliName}_hook.log');
+  }
+
+  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);
+    }
+    
+    // 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) {
+    // Simple pattern matching for cross-CLI requests
+    const patterns = [
+      /(?:use|call|ask)\\s+(\\w+)\\s+(?:to|for)\\s+(.+)$/i,
+      /(?:use|call|ask)\\s+(\\w+)\\s+(?:to|for)\\s+(.+)$/i  // English-only pattern
+    ];
+    
+    for (const pattern of patterns) {
+      const match = prompt.match(pattern);
+      if (match) {
+        return {
+          targetCLI: match[1].toLowerCase(),
+          task: match[2] || match[3],
+          source: this.cliName
+        };
+      }
+    }
+    
+    return null;
+  }
+
+  async handleCrossCLIRequest(request, context) {
+    this.log('INFO', \`Cross-CLI request detected: \${JSON.stringify(request)}\`);
+    
+    // In a real implementation, this would communicate with the coordination layer
+    // For now, we simulate the response
+    return \`[NODE.JS HOOK] Simulated cross-CLI call to \${request.targetCLI}: \${request.task}\`;
+  }
+
+  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);
+    }
+  }
+
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+}
+
+// Export the hook class
+module.exports = ${this.capitalize(cliName)}NodeJsHook;
+
+// 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');
+}
+`;
+  }
+
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  async undeployHooksForCLI(cliName) {
+    console.log(`[HOOK_DEPLOYMENT] Undeploying hooks for ${cliName}...`);
+    
+    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;
+      }
+    }
+    
+    console.log(`[HOOK_DEPLOYMENT] No hooks found for ${cliName}`);
+    return true;
+  }
+
+  async listDeployedHooks() {
+    if (!fs.existsSync(this.deploymentDir)) {
+      return [];
+    }
+    
+    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;
+  }
+
+  async validateHookDeployment(cliName) {
+    console.log(`[HOOK_DEPLOYMENT] Validating hook deployment for ${cliName}...`);
+    
+    const cliHookDir = path.join(this.deploymentDir, cliName);
+    if (!fs.existsSync(cliHookDir)) {
+      return { valid: false, error: 'Hook directory not found' };
+    }
+    
+    const configPath = path.join(cliHookDir, 'config.json');
+    if (!fs.existsSync(configPath)) {
+      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' };
+    } catch (error) {
+      return { valid: false, error: `Failed to load hook: ${error.message}` };
+    }
+  }
+}
+
+module.exports = HookDeploymentManager;

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

@@ -0,0 +1,71 @@
+// src/core/coordination/nodejs/StatisticsCollector.js
+class StatisticsCollector {
+  constructor() {
+    this.counters = {};
+    this.timings = {};
+    this.startTime = Date.now();
+  }
+
+  initialize() {
+    console.log('[STATISTICS_COLLECTOR] Initializing statistics collector...');
+    this.reset();
+  }
+
+  reset() {
+    this.counters = {
+      cross_cli_calls: 0,
+      successful_calls: 0,
+      failed_calls: 0,
+      adapter_loads: 0
+    };
+    this.timings = {
+      execution_times: [],
+      last_reset: Date.now()
+    };
+  }
+
+  incrementCounter(name) {
+    this.counters[name] = (this.counters[name] || 0) + 1;
+  }
+
+  recordExecutionTime(timeMs) {
+    this.timings.execution_times.push(timeMs);
+    // Keep only last 1000 timings to prevent memory bloat
+    if (this.timings.execution_times.length > 1000) {
+      this.timings.execution_times.shift();
+    }
+  }
+
+  getAdapterStats(cliName) {
+    return {
+      calls: this.counters.cross_cli_calls,
+      successRate: this.calculateSuccessRate(),
+      averageExecutionTime: this.calculateAverageExecutionTime(),
+      uptime: Date.now() - this.startTime
+    };
+  }
+
+  getAllStats() {
+    return {
+      counters: this.counters,
+      timings: {
+        ...this.timings,
+        averageExecutionTime: this.calculateAverageExecutionTime()
+      },
+      uptime: Date.now() - this.startTime
+    };
+  }
+
+  calculateSuccessRate() {
+    if (this.counters.cross_cli_calls === 0) return 1.0;
+    return this.counters.successful_calls / this.counters.cross_cli_calls;
+  }
+
+  calculateAverageExecutionTime() {
+    if (this.timings.execution_times.length === 0) return 0;
+    const sum = this.timings.execution_times.reduce((a, b) => a + b, 0);
+    return sum / this.timings.execution_times.length;
+  }
+}
+
+module.exports = StatisticsCollector;

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

@@ -0,0 +1,72 @@
+// src/core/coordination/nodejs/index.js
+const AdapterManager = require('./AdapterManager');
+const CLCommunication = require('./CLCommunication');
+const StatisticsCollector = require('./StatisticsCollector');
+const HealthChecker = require('./HealthChecker');
+
+class NodeJsCoordinationLayer {
+  constructor() {
+    this.adapterManager = new AdapterManager();
+    this.communication = new CLCommunication();
+    this.statistics = new StatisticsCollector();
+    this.healthChecker = new HealthChecker();
+  }
+
+  async initialize(options = {}) {
+    try {
+      console.log('[NODEJS_COORDINATION] Initializing Node.js coordination layer...');
+      
+      // Initialize components
+      await this.adapterManager.initialize();
+      await this.communication.initialize();
+      this.statistics.initialize();
+      
+      // Perform health check
+      const health = await this.healthChecker.checkHealth();
+      if (!health.healthy) {
+        console.warn('[NODEJS_COORDINATION] Health check issues detected:', health);
+      }
+      
+      console.log('[NODEJS_COORDINATION] Node.js coordination layer initialized successfully');
+      return true;
+    } catch (error) {
+      console.error('[NODEJS_COORDINATION] Failed to initialize Node.js coordination layer:', error);
+      return false;
+    }
+  }
+
+  async executeCrossCLITask(sourceCLI, targetCLI, task, context = {}) {
+    this.statistics.incrementCounter('cross_cli_calls');
+    const startTime = Date.now();
+
+    try {
+      const result = await this.communication.executeTask(sourceCLI, targetCLI, task, context);
+      this.statistics.recordExecutionTime(Date.now() - startTime);
+      this.statistics.incrementCounter('successful_calls');
+      return result;
+    } catch (error) {
+      this.statistics.incrementCounter('failed_calls');
+      console.error(`[NODEJS_COORDINATION] Cross-CLI task execution failed:`, error);
+      throw error;
+    }
+  }
+
+  async getAdapterStatistics(cliName) {
+    return this.statistics.getAdapterStats(cliName);
+  }
+
+  async getSystemStatus() {
+    return {
+      implementation: 'nodejs',
+      health: await this.healthChecker.checkHealth(),
+      statistics: this.statistics.getAllStats(),
+      adapters: await this.adapterManager.listAdapters()
+    };
+  }
+
+  async healthCheck() {
+    return await this.healthChecker.checkHealth();
+  }
+}
+
+module.exports = NodeJsCoordinationLayer;