stigmergy 1.2.6 → 1.2.8

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

@@ -1,102 +1,102 @@
-// src/core/coordination/nodejs/AdapterManager.js
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-class AdapterManager {
-  constructor() {
-    this.adapters = new Map();
-    this.discoveryPaths = [
-      path.join(__dirname, '..', '..', '..', 'adapters'),
-      path.join(os.homedir(), '.stigmergy', 'adapters'),
-    ];
-  }
-
-  async initialize() {
-    console.log('[ADAPTER_MANAGER] Initializing adapter manager...');
-    await this.discoverAdapters();
-  }
-
-  async discoverAdapters() {
-    console.log('[ADAPTER_MANAGER] Discovering adapters...');
-
-    for (const basePath of this.discoveryPaths) {
-      if (fs.existsSync(basePath)) {
-        try {
-          const adapterDirs = fs
-            .readdirSync(basePath, { withFileTypes: true })
-            .filter((dirent) => dirent.isDirectory())
-            .map((dirent) => dirent.name);
-
-          console.log(
-            `[ADAPTER_MANAGER] Found ${adapterDirs.length} adapter directories in ${basePath}`,
-          );
-
-          for (const dir of adapterDirs) {
-            await this.loadAdapter(dir, basePath);
-          }
-        } catch (error) {
-          console.warn(
-            `[ADAPTER_MANAGER] Failed to read adapter directory ${basePath}:`,
-            error.message,
-          );
-        }
-      } else {
-        console.log(
-          `[ADAPTER_MANAGER] Adapter path does not exist: ${basePath}`,
-        );
-      }
-    }
-  }
-
-  async loadAdapter(adapterName, basePath) {
-    const adapterPath = path.join(basePath, adapterName, 'index.js');
-
-    if (fs.existsSync(adapterPath)) {
-      try {
-        // Create a simple adapter wrapper for Node.js
-        const adapter = {
-          name: adapterName,
-          path: adapterPath,
-          available: true,
-          version: '1.0.0-nodejs',
-          isAvailable: async () => true,
-          executeTask: async (task, context) => {
-            // Simple task execution simulation
-            return `[${adapterName.toUpperCase()} NODE.JS ADAPTER] Executed: ${task}`;
-          },
-        };
-
-        this.adapters.set(adapterName, adapter);
-        console.log(`[ADAPTER_MANAGER] Loaded Node.js adapter: ${adapterName}`);
-      } catch (error) {
-        console.warn(
-          `[ADAPTER_MANAGER] Failed to load adapter from ${adapterPath}:`,
-          error.message,
-        );
-      }
-    } else {
-      console.log(
-        `[ADAPTER_MANAGER] Adapter index.js not found for: ${adapterName}`,
-      );
-    }
-  }
-
-  getAdapter(cliName) {
-    return this.adapters.get(cliName.toLowerCase());
-  }
-
-  async listAdapters() {
-    const adapterList = [];
-    for (const [name, adapter] of this.adapters) {
-      adapterList.push({
-        name,
-        available: await adapter.isAvailable(),
-        version: adapter.version || 'unknown',
-      });
-    }
-    return adapterList;
-  }
-}
-
-module.exports = AdapterManager;
+// src/core/coordination/nodejs/AdapterManager.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class AdapterManager {
+  constructor() {
+    this.adapters = new Map();
+    this.discoveryPaths = [
+      path.join(__dirname, '..', '..', '..', 'adapters'),
+      path.join(os.homedir(), '.stigmergy', 'adapters'),
+    ];
+  }
+
+  async initialize() {
+    console.log('[ADAPTER_MANAGER] Initializing adapter manager...');
+    await this.discoverAdapters();
+  }
+
+  async discoverAdapters() {
+    console.log('[ADAPTER_MANAGER] Discovering adapters...');
+
+    for (const basePath of this.discoveryPaths) {
+      if (fs.existsSync(basePath)) {
+        try {
+          const adapterDirs = fs
+            .readdirSync(basePath, { withFileTypes: true })
+            .filter((dirent) => dirent.isDirectory())
+            .map((dirent) => dirent.name);
+
+          console.log(
+            `[ADAPTER_MANAGER] Found ${adapterDirs.length} adapter directories in ${basePath}`,
+          );
+
+          for (const dir of adapterDirs) {
+            await this.loadAdapter(dir, basePath);
+          }
+        } catch (error) {
+          console.warn(
+            `[ADAPTER_MANAGER] Failed to read adapter directory ${basePath}:`,
+            error.message,
+          );
+        }
+      } else {
+        console.log(
+          `[ADAPTER_MANAGER] Adapter path does not exist: ${basePath}`,
+        );
+      }
+    }
+  }
+
+  async loadAdapter(adapterName, basePath) {
+    const adapterPath = path.join(basePath, adapterName, 'index.js');
+
+    if (fs.existsSync(adapterPath)) {
+      try {
+        // Create a simple adapter wrapper for Node.js
+        const adapter = {
+          name: adapterName,
+          path: adapterPath,
+          available: true,
+          version: '1.0.0-nodejs',
+          isAvailable: async () => true,
+          executeTask: async (task, context) => {
+            // Simple task execution simulation
+            return `[${adapterName.toUpperCase()} NODE.JS ADAPTER] Executed: ${task}`;
+          },
+        };
+
+        this.adapters.set(adapterName, adapter);
+        console.log(`[ADAPTER_MANAGER] Loaded Node.js adapter: ${adapterName}`);
+      } catch (error) {
+        console.warn(
+          `[ADAPTER_MANAGER] Failed to load adapter from ${adapterPath}:`,
+          error.message,
+        );
+      }
+    } else {
+      console.log(
+        `[ADAPTER_MANAGER] Adapter index.js not found for: ${adapterName}`,
+      );
+    }
+  }
+
+  getAdapter(cliName) {
+    return this.adapters.get(cliName.toLowerCase());
+  }
+
+  async listAdapters() {
+    const adapterList = [];
+    for (const [name, adapter] of this.adapters) {
+      adapterList.push({
+        name,
+        available: await adapter.isAvailable(),
+        version: adapter.version || 'unknown',
+      });
+    }
+    return adapterList;
+  }
+}
+
+module.exports = AdapterManager;

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

@@ -1,132 +1,132 @@
-// src/core/coordination/nodejs/CLCommunication.js
-const { spawn } = require('child_process');
-const path = require('path');
-
-class CLCommunication {
-  constructor() {
-    this.executionTimeout = 30000; // 30 seconds
-  }
-
-  async initialize() {
-    console.log('[CL_COMMUNICATION] Initializing cross-CLI communication...');
-  }
-
-  async executeTask(sourceCLI, targetCLI, task, context) {
-    console.log(
-      `[CL_COMMUNICATION] Executing task from ${sourceCLI} to ${targetCLI}: ${task}`,
-    );
-
-    try {
-      // Execute the target CLI with the task
-      const result = await this.executeCLICommand(targetCLI, task);
-      return result;
-    } catch (error) {
-      console.error(
-        `[CL_COMMUNICATION] Failed to execute task for ${targetCLI}:`,
-        error,
-      );
-      throw error;
-    }
-  }
-
-  async executeCLICommand(cliName, task) {
-    return new Promise((resolve, reject) => {
-      // Prepare arguments based on the CLI type for non-interactive execution
-      const args = this.prepareCLIArguments(cliName, task);
-
-      // Spawn the CLI command
-      const child = spawn(cliName, args, {
-        encoding: 'utf8',
-        timeout: this.executionTimeout,
-        shell: true,
-      });
-
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      child.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        if (code === 0) {
-          resolve({
-            success: true,
-            output: stdout.trim(),
-            code: code,
-          });
-        } else {
-          reject({
-            success: false,
-            error:
-              stderr.trim() ||
-              stdout.trim() ||
-              `Process exited with code ${code}`,
-            code: code,
-          });
-        }
-      });
-
-      child.on('error', (error) => {
-        reject({
-          success: false,
-          error: `Failed to spawn process: ${error.message}`,
-          code: null,
-        });
-      });
-
-      child.on('timeout', () => {
-        child.kill();
-        reject({
-          success: false,
-          error: `Command timed out after ${this.executionTimeout}ms`,
-          code: null,
-        });
-      });
-    });
-  }
-
-  prepareCLIArguments(cliName, task) {
-    // Prepare arguments based on the CLI type for non-interactive execution
-    const cliTypes = {
-      // CLIs that support -p flag for prompt
-      claude: ['-p', task],
-      qwen: ['-p', task],
-      gemini: ['-p', task],
-      iflow: ['-p', task],
-      // CLIs that support direct prompt as argument
-      qodercli: [task],
-      codebuddy: [task],
-      copilot: [task],
-      codex: [task],
-    };
-
-    const args = cliTypes[cliName];
-    return args || ['-p', task]; // Default to -p flag if not specified
-  }
-
-  getAdapter(cliName) {
-    // Return a real adapter that can execute CLI commands
-    return {
-      name: cliName,
-      executeTask: async (task, context) => {
-        try {
-          const result = await this.executeCLICommand(cliName, task);
-          return result.output;
-        } catch (error) {
-          return `[${cliName.toUpperCase()} ERROR] ${error.error || error.message}`;
-        }
-      },
-    };
-  }
-
-  generateTaskId() {
-    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-}
-
-module.exports = CLCommunication;
+// src/core/coordination/nodejs/CLCommunication.js
+const { spawn } = require('child_process');
+const path = require('path');
+
+class CLCommunication {
+  constructor() {
+    this.executionTimeout = 30000; // 30 seconds
+  }
+
+  async initialize() {
+    console.log('[CL_COMMUNICATION] Initializing cross-CLI communication...');
+  }
+
+  async executeTask(sourceCLI, targetCLI, task, context) {
+    console.log(
+      `[CL_COMMUNICATION] Executing task from ${sourceCLI} to ${targetCLI}: ${task}`,
+    );
+
+    try {
+      // Execute the target CLI with the task
+      const result = await this.executeCLICommand(targetCLI, task);
+      return result;
+    } catch (error) {
+      console.error(
+        `[CL_COMMUNICATION] Failed to execute task for ${targetCLI}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  async executeCLICommand(cliName, task) {
+    return new Promise((resolve, reject) => {
+      // Prepare arguments based on the CLI type for non-interactive execution
+      const args = this.prepareCLIArguments(cliName, task);
+
+      // Spawn the CLI command
+      const child = spawn(cliName, args, {
+        encoding: 'utf8',
+        timeout: this.executionTimeout,
+        shell: true,
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            success: true,
+            output: stdout.trim(),
+            code: code,
+          });
+        } else {
+          reject({
+            success: false,
+            error:
+              stderr.trim() ||
+              stdout.trim() ||
+              `Process exited with code ${code}`,
+            code: code,
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        reject({
+          success: false,
+          error: `Failed to spawn process: ${error.message}`,
+          code: null,
+        });
+      });
+
+      child.on('timeout', () => {
+        child.kill();
+        reject({
+          success: false,
+          error: `Command timed out after ${this.executionTimeout}ms`,
+          code: null,
+        });
+      });
+    });
+  }
+
+  prepareCLIArguments(cliName, task) {
+    // Prepare arguments based on the CLI type for non-interactive execution
+    const cliTypes = {
+      // CLIs that support -p flag for prompt
+      claude: ['-p', task],
+      qwen: ['-p', task],
+      gemini: ['-p', task],
+      iflow: ['-p', task],
+      // CLIs that support direct prompt as argument
+      qodercli: [task],
+      codebuddy: [task],
+      copilot: [task],
+      codex: [task],
+    };
+
+    const args = cliTypes[cliName];
+    return args || ['-p', task]; // Default to -p flag if not specified
+  }
+
+  getAdapter(cliName) {
+    // Return a real adapter that can execute CLI commands
+    return {
+      name: cliName,
+      executeTask: async (task, context) => {
+        try {
+          const result = await this.executeCLICommand(cliName, task);
+          return result.output;
+        } catch (error) {
+          return `[${cliName.toUpperCase()} ERROR] ${error.error || error.message}`;
+        }
+      },
+    };
+  }
+
+  generateTaskId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+}
+
+module.exports = CLCommunication;