stigmergy 1.2.6 → 1.2.10

package/src/core/cli_tools.js

@@ -1,89 +1,160 @@
-const path = require('path');
-const os = require('os');
-const { errorHandler, ERROR_TYPES } = require('./error_handler');
-
-// AI CLI Tools Configuration
-const CLI_TOOLS = {
-  claude: {
-    name: 'Claude CLI',
-    version: 'claude --version',
-    install: 'npm install -g @anthropic-ai/claude-cli',
-    hooksDir: path.join(os.homedir(), '.claude', 'hooks'),
-    config: path.join(os.homedir(), '.claude', 'config.json'),
-  },
-  gemini: {
-    name: 'Gemini CLI',
-    version: 'gemini --version',
-    install: 'npm install -g @google/generative-ai-cli',
-    hooksDir: path.join(os.homedir(), '.gemini', 'extensions'),
-    config: path.join(os.homedir(), '.gemini', 'config.json'),
-  },
-  qwen: {
-    name: 'Qwen CLI',
-    version: 'qwen --version',
-    install: 'npm install -g @qwen-code/qwen-code',
-    hooksDir: path.join(os.homedir(), '.qwen', 'hooks'),
-    config: path.join(os.homedir(), '.qwen', 'config.json'),
-  },
-  iflow: {
-    name: 'iFlow CLI',
-    version: 'iflow --version',
-    install: 'npm install -g iflow-cli',
-    hooksDir: path.join(os.homedir(), '.iflow', 'hooks'),
-    config: path.join(os.homedir(), '.iflow', 'config.json'),
-  },
-  qodercli: {
-    name: 'Qoder CLI',
-    version: 'qodercli --version',
-    install: 'npm install -g @qoder-ai/qodercli',
-    hooksDir: path.join(os.homedir(), '.qoder', 'hooks'),
-    config: path.join(os.homedir(), '.qoder', 'config.json'),
-  },
-  codebuddy: {
-    name: 'CodeBuddy CLI',
-    version: 'codebuddy --version',
-    install: 'npm install -g codebuddy-cli',
-    hooksDir: path.join(os.homedir(), '.codebuddy', 'hooks'),
-    config: path.join(os.homedir(), '.codebuddy', 'config.json'),
-  },
-  copilot: {
-    name: 'GitHub Copilot CLI',
-    version: 'copilot --version',
-    install: 'npm install -g @github/copilot-cli',
-    hooksDir: path.join(os.homedir(), '.copilot', 'mcp'),
-    config: path.join(os.homedir(), '.copilot', 'config.json'),
-  },
-  codex: {
-    name: 'OpenAI Codex CLI',
-    version: 'codex --version',
-    install: 'npm install -g openai-codex-cli',
-    hooksDir: path.join(os.homedir(), '.config', 'codex', 'slash_commands'),
-    config: path.join(os.homedir(), '.codex', 'config.json'),
-  },
-};
-
-/**
- * Validate CLI tool configuration
- * @param {string} toolName - Name of the tool to validate
- * @throws {StigmergyError} If validation fails
- */
-function validateCLITool(toolName) {
-  if (!CLI_TOOLS[toolName]) {
-    throw errorHandler.createError(
-      `CLI tool '${toolName}' is not configured`,
-      ERROR_TYPES.CONFIGURATION,
-      'INVALID_CLI_TOOL',
-    );
-  }
-
-  const tool = CLI_TOOLS[toolName];
-  if (!tool.name || !tool.version || !tool.install) {
-    throw errorHandler.createError(
-      `CLI tool '${toolName}' has invalid configuration`,
-      ERROR_TYPES.CONFIGURATION,
-      'INCOMPLETE_CLI_CONFIG',
-    );
-  }
-}
-
-module.exports = { CLI_TOOLS, validateCLITool };
+const path = require('path');
+const os = require('os');
+const { errorHandler, ERROR_TYPES } = require('./error_handler');
+const CLIPathDetector = require('./cli_path_detector');
+
+// AI CLI Tools Configuration
+const CLI_TOOLS = {
+  claude: {
+    name: 'Claude CLI',
+    version: 'claude --version',
+    install: 'npm install -g @anthropic-ai/claude-code',
+    hooksDir: path.join(os.homedir(), '.claude', 'hooks'),
+    config: path.join(os.homedir(), '.claude', 'config.json'),
+  },
+  gemini: {
+    name: 'Gemini CLI',
+    version: 'gemini --version',
+    install: 'npm install -g @google/gemini-cli',
+    hooksDir: path.join(os.homedir(), '.gemini', 'extensions'),
+    config: path.join(os.homedir(), '.gemini', 'config.json'),
+  },
+  qwen: {
+    name: 'Qwen CLI',
+    version: 'qwen --version',
+    install: 'npm install -g @qwen-code/qwen-code',
+    hooksDir: path.join(os.homedir(), '.qwen', 'hooks'),
+    config: path.join(os.homedir(), '.qwen', 'config.json'),
+  },
+  iflow: {
+    name: 'iFlow CLI',
+    version: 'iflow --version',
+    install: 'npm install -g @iflow-ai/iflow-cli',
+    hooksDir: path.join(os.homedir(), '.iflow', 'hooks'),
+    config: path.join(os.homedir(), '.iflow', 'config.json'),
+  },
+  qodercli: {
+    name: 'Qoder CLI',
+    version: 'qodercli --version',
+    install: 'npm install -g @qoder-ai/qodercli',
+    hooksDir: path.join(os.homedir(), '.qoder', 'hooks'),
+    config: path.join(os.homedir(), '.qoder', 'config.json'),
+  },
+  codebuddy: {
+    name: 'CodeBuddy CLI',
+    version: 'codebuddy --version',
+    install: 'npm install -g @tencent-ai/codebuddy-code',
+    hooksDir: path.join(os.homedir(), '.codebuddy', 'hooks'),
+    config: path.join(os.homedir(), '.codebuddy', 'config.json'),
+  },
+  copilot: {
+    name: 'GitHub Copilot CLI',
+    version: 'copilot --version',
+    install: 'npm install -g @github/copilot',
+    hooksDir: path.join(os.homedir(), '.copilot', 'mcp'),
+    config: path.join(os.homedir(), '.copilot', 'config.json'),
+  },
+  codex: {
+    name: 'OpenAI Codex CLI',
+    version: 'codex --version',
+    install: 'npm install -g @openai/codex',
+    hooksDir: path.join(os.homedir(), '.config', 'codex', 'slash_commands'),
+    config: path.join(os.homedir(), '.codex', 'config.json'),
+  },
+};
+
+/**
+ * Validate CLI tool configuration
+ * @param {string} toolName - Name of the tool to validate
+ * @throws {StigmergyError} If validation fails
+ */
+function validateCLITool(toolName) {
+  if (!CLI_TOOLS[toolName]) {
+    throw errorHandler.createError(
+      `CLI tool '${toolName}' is not configured`,
+      ERROR_TYPES.CONFIGURATION,
+      'INVALID_CLI_TOOL',
+    );
+  }
+
+  const tool = CLI_TOOLS[toolName];
+  if (!tool.name || !tool.version || !tool.install) {
+    throw errorHandler.createError(
+      `CLI tool '${toolName}' has invalid configuration`,
+      ERROR_TYPES.CONFIGURATION,
+      'INCOMPLETE_CLI_CONFIG',
+    );
+  }
+}
+
+/**
+ * Create global path detector instance (lazy initialization)
+ */
+let pathDetector = null;
+
+function getPathDetector() {
+  if (!pathDetector) {
+    pathDetector = new CLIPathDetector();
+  }
+  return pathDetector;
+}
+
+/**
+ * Initialize path detection and load cached paths
+ */
+async function initializePathDetection() {
+  const detector = getPathDetector();
+  await detector.loadDetectedPaths();
+}
+
+/**
+ * Get CLI tool path with automatic detection fallback
+ */
+async function getCLIPath(toolName) {
+  const detector = getPathDetector();
+
+  // Check cached paths first
+  let toolPath = detector.getDetectedPath(toolName);
+  if (toolPath) {
+    return toolPath;
+  }
+
+  // If not cached, detect and update
+  console.log(`[PATH] Detecting path for ${toolName}...`);
+  toolPath = await detector.detectCLIPath(toolName);
+
+  return toolPath;
+}
+
+/**
+ * Update PATH configuration and run path detection
+ */
+async function setupCLIPaths() {
+  console.log('[PATH] Setting up CLI paths configuration...');
+
+  const detector = getPathDetector();
+
+  // 1. Load existing cached paths
+  await detector.loadDetectedPaths();
+
+  // 2. Detect all CLI paths
+  const detectedPaths = await detector.detectAllCLIPaths();
+
+  // 3. Check and update PATH if needed
+  const pathStatus = await detector.updatePATHIfMissing();
+
+  return {
+    detectedPaths,
+    pathStatus,
+    report: detector.getPathStatusReport()
+  };
+}
+
+module.exports = {
+  CLI_TOOLS,
+  validateCLITool,
+  initializePathDetection,
+  getCLIPath,
+  setupCLIPaths,
+  CLIPathDetector
+};

package/src/core/coordination/index.js

@@ -1,16 +1,16 @@
-// Update main coordination layer to include Node.js components
-// src/core/coordination/index.js
-
-// Existing content would be here...
-
-// Add Node.js coordination layer exports
-const NodeJsCoordinationLayer = require('./nodejs');
-const HookDeploymentManager = require('./nodejs/HookDeploymentManager');
-const CLIIntegrationManager = require('./nodejs/CLIIntegrationManager');
-
-module.exports = {
-  // Existing exports...
-  NodeJsCoordinationLayer,
-  HookDeploymentManager,
-  CLIIntegrationManager,
-};
+// Update main coordination layer to include Node.js components
+// src/core/coordination/index.js
+
+// Existing content would be here...
+
+// Add Node.js coordination layer exports
+const NodeJsCoordinationLayer = require('./nodejs');
+const HookDeploymentManager = require('./nodejs/HookDeploymentManager');
+const CLIIntegrationManager = require('./nodejs/CLIIntegrationManager');
+
+module.exports = {
+  // Existing exports...
+  NodeJsCoordinationLayer,
+  HookDeploymentManager,
+  CLIIntegrationManager,
+};

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

@@ -1,102 +1,130 @@
-// 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();
+    // Try multiple approaches for the adapters path to handle different installation scenarios
+    const primaryAdapterPath = this.findAdaptersPath();
+    this.discoveryPaths = [
+      primaryAdapterPath,
+      path.join(os.homedir(), '.stigmergy', 'adapters'),
+    ];
+  }
+
+  /**
+   * Find the adapters path using multiple approaches to handle different installation scenarios
+   */
+  findAdaptersPath() {
+    const possiblePaths = [
+      // Standard path: src/core/coordination/nodejs/../../../adapters => src/adapters
+      path.join(__dirname, '..', '..', '..', 'adapters'),
+      // Fallback path in case of different module resolution
+      path.resolve(__dirname, '..', '..', '..', 'adapters'),
+      // Alternative approach: go to project root and then to adapters
+      path.join(__dirname, '..', '..', '..', '..', 'adapters')
+    ];
+
+    for (const possiblePath of possiblePaths) {
+      if (fs.existsSync(possiblePath)) {
+        console.log(`[DEBUG] AdapterManager found adapters at: ${possiblePath}`);
+        return possiblePath;
+      }
+    }
+
+    // If none of the paths work, use the standard path as fallback (might not exist)
+    const fallbackPath = path.join(__dirname, '..', '..', '..', 'adapters');
+    console.log(`[DEBUG] AdapterManager using fallback adapters path (may not exist): ${fallbackPath}`);
+    return fallbackPath;
+  }
+
+  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;