stigmergy 1.2.0 → 1.2.6

package/src/core/cli_parameter_handler.js

@@ -1,127 +1,132 @@
-// Unified CLI Parameter Handler
-const { spawn } = require('child_process');
-
-class CLIParameterHandler {
-  /**
-   * Generate appropriate arguments for CLI execution based on tool patterns
-   * @param {string} toolName - Name of the CLI tool
-   * @param {string} prompt - User prompt
-   * @param {Object} cliPattern - CLI pattern information from analyzer
-   * @returns {Array} Arguments array for spawn
-   */
-  static generateArguments(toolName, prompt, cliPattern) {
-    // Default arguments
-    let toolArgs = [];
-
-    // Special handling for Codex CLI which always needs 'exec' subcommand
-    if (toolName === 'codex') {
-      return ['exec', '-p', `"${prompt}"`];
-    }
-
-    try {
-      // Check if we have pattern information from CLI help analyzer
-      if (cliPattern && cliPattern.commandStructure) {
-        const commandStructure = cliPattern.commandStructure;
-
-        // Handle based on command structure and patterns from help analyzer
-        if (commandStructure.nonInteractiveSupport) {
-          // Use flag-based approach if available
-          if (commandStructure.promptFlag) {
-            toolArgs = [commandStructure.promptFlag, `"${prompt}"`];
-          } else if (commandStructure.nonInteractiveFlag) {
-            toolArgs = [commandStructure.nonInteractiveFlag, `"${prompt}"`];
-          } else {
-            // Fallback to standard -p flag
-            toolArgs = ['-p', `"${prompt}"`];
-          }
-        } else if (commandStructure.executionPattern === 'flag-based') {
-          // Explicitly flag-based tools
-          if (commandStructure.promptFlag) {
-            toolArgs = [commandStructure.promptFlag, `"${prompt}"`];
-          } else {
-            toolArgs = ['-p', `"${prompt}"`];
-          }
-        } else if (commandStructure.executionPattern === 'argument-based') {
-          // Argument-based tools
-          toolArgs = [`"${prompt}"`];
-        } else if (commandStructure.executionPattern === 'subcommand-based') {
-          // Subcommand-based tools
-          toolArgs = ['-p', `"${prompt}"`];
-        } else {
-          // Fallback to tool-specific handling
-          toolArgs = this.getToolSpecificArguments(toolName, prompt);
-        }
-      } else {
-        // Fallback to tool-specific handling if no pattern information
-        toolArgs = this.getToolSpecificArguments(toolName, prompt);
-      }
-    } catch (error) {
-      // Final fallback to tool-specific handling
-      toolArgs = this.getToolSpecificArguments(toolName, prompt);
-    }
-
-    return toolArgs;
-  }
-
-  /**
-   * Get tool-specific arguments based on known patterns
-   * @param {string} toolName - Name of the CLI tool
-   * @param {string} prompt - User prompt
-   * @returns {Array} Arguments array for spawn
-   */
-  static getToolSpecificArguments(toolName, prompt) {
-    // Tool-specific argument handling
-    const toolSpecificArgs = {
-      claude: ['-p', `"${prompt}"`],
-      qodercli: ['-p', `"${prompt}"`],
-      iflow: ['-p', `"${prompt}"`],
-      codebuddy: ['-p', `"${prompt}"`],
-      copilot: ['-p', `"${prompt}"`],
-      codex: ['exec', '-p', `"${prompt}"`], // Codex needs 'exec' subcommand
-    };
-
-    // Return tool-specific arguments if available
-    if (toolSpecificArgs[toolName]) {
-      return toolSpecificArgs[toolName];
-    }
-
-    // Default handling for other tools
-    // Check if the tool commonly uses -p flag
-    const toolsWithPFlag = [
-      'claude',
-      'qodercli',
-      'iflow',
-      'codebuddy',
-      'copilot',
-    ];
-    if (toolsWithPFlag.includes(toolName)) {
-      return ['-p', `"${prompt}"`];
-    }
-
-    // Default to argument-based approach
-    return [`"${prompt}"`];
-  }
-
-  /**
-   * Execute CLI tool with appropriate arguments
-   * @param {string} toolPath - Path to the CLI tool
-   * @param {string} toolName - Name of the CLI tool
-   * @param {string} prompt - User prompt
-   * @param {Object} cliPattern - CLI pattern information from analyzer
-   * @returns {Object} Child process object
-   */
-  static executeCLI(toolPath, toolName, prompt, cliPattern) {
-    // Generate appropriate arguments
-    const toolArgs = this.generateArguments(toolName, prompt, cliPattern);
-
-    // Execute the tool
-    const child = spawn(toolPath, toolArgs, {
-      stdio: 'inherit',
-      shell: true,
-    });
-
-    return child;
-  }
-}
-
-module.exports = CLIParameterHandler;
+// Unified CLI Parameter Handler
+const { spawn } = require('child_process');
+
+class CLIParameterHandler {
+  /**
+   * Generate appropriate arguments for CLI execution based on tool patterns
+   * @param {string} toolName - Name of the CLI tool
+   * @param {string} prompt - User prompt
+   * @param {Object} cliPattern - CLI pattern information from analyzer
+   * @returns {Array} Arguments array for spawn
+   */
+  static generateArguments(toolName, prompt, cliPattern) {
+    // Default arguments
+    let toolArgs = [];
+
+    // Special handling for Codex CLI which always needs 'exec' subcommand
+    if (toolName === 'codex') {
+      return ['exec', '-p', `"${prompt}"`];
+    }
+
+    try {
+      // Check if we have pattern information from CLI help analyzer
+      if (cliPattern && cliPattern.commandStructure) {
+        const commandStructure = cliPattern.commandStructure;
+
+        // Handle based on command structure and patterns from help analyzer
+        if (commandStructure.nonInteractiveSupport) {
+          // Use flag-based approach if available
+          if (commandStructure.promptFlag) {
+            toolArgs = [commandStructure.promptFlag, `"${prompt}"`];
+          } else if (commandStructure.nonInteractiveFlag) {
+            toolArgs = [commandStructure.nonInteractiveFlag, `"${prompt}"`];
+          } else {
+            // Fallback to standard -p flag
+            toolArgs = ['-p', `"${prompt}"`];
+          }
+        } else if (commandStructure.executionPattern === 'flag-based') {
+          // Explicitly flag-based tools
+          if (commandStructure.promptFlag) {
+            toolArgs = [commandStructure.promptFlag, `"${prompt}"`];
+          } else {
+            toolArgs = ['-p', `"${prompt}"`];
+          }
+        } else if (commandStructure.executionPattern === 'argument-based') {
+          // Argument-based tools
+          toolArgs = [`"${prompt}"`];
+        } else if (commandStructure.executionPattern === 'subcommand-based') {
+          // Subcommand-based tools
+          toolArgs = ['-p', `"${prompt}"`];
+        } else {
+          // Fallback to tool-specific handling
+          toolArgs = this.getToolSpecificArguments(toolName, prompt);
+        }
+      } else {
+        // Fallback to tool-specific handling if no pattern information
+        toolArgs = this.getToolSpecificArguments(toolName, prompt);
+      }
+    } catch (error) {
+      // Final fallback to tool-specific handling
+      toolArgs = this.getToolSpecificArguments(toolName, prompt);
+    }
+
+    // Add debug logging to trace parameter generation
+    console.log(`[DEBUG] Parameter generation for ${toolName}:`);
+    console.log(`[DEBUG] Prompt: ${prompt}`);
+    console.log(`[DEBUG] Generated args: ${JSON.stringify(toolArgs)}`);
+    
+    return toolArgs;
+  }
+
+  /**
+   * Get tool-specific arguments based on known patterns
+   * @param {string} toolName - Name of the CLI tool
+   * @param {string} prompt - User prompt
+   * @returns {Array} Arguments array for spawn
+   */
+  static getToolSpecificArguments(toolName, prompt) {
+    // Tool-specific argument handling
+    const toolSpecificArgs = {
+      claude: ['-p', `"${prompt}"`],
+      qodercli: ['-p', `"${prompt}"`],
+      iflow: ['-p', `"${prompt}"`],
+      codebuddy: ['-p', `"${prompt}"`],
+      copilot: ['-p', `"${prompt}"`],
+      codex: ['exec', '-p', `"${prompt}"`], // Codex needs 'exec' subcommand
+    };
+
+    // Return tool-specific arguments if available
+    if (toolSpecificArgs[toolName]) {
+      return toolSpecificArgs[toolName];
+    }
+
+    // Default handling for other tools
+    // Check if the tool commonly uses -p flag
+    const toolsWithPFlag = [
+      'claude',
+      'qodercli',
+      'iflow',
+      'codebuddy',
+      'copilot',
+    ];
+    if (toolsWithPFlag.includes(toolName)) {
+      return ['-p', `"${prompt}"`];
+    }
+
+    // Default to argument-based approach
+    return [`"${prompt}"`];
+  }
+
+  /**
+   * Execute CLI tool with appropriate arguments
+   * @param {string} toolPath - Path to the CLI tool
+   * @param {string} toolName - Name of the CLI tool
+   * @param {string} prompt - User prompt
+   * @param {Object} cliPattern - CLI pattern information from analyzer
+   * @returns {Object} Child process object
+   */
+  static executeCLI(toolPath, toolName, prompt, cliPattern) {
+    // Generate appropriate arguments
+    const toolArgs = this.generateArguments(toolName, prompt, cliPattern);
+
+    // Execute the tool
+    const child = spawn(toolPath, toolArgs, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return child;
+  }
+}
+
+module.exports = CLIParameterHandler;

package/src/core/cli_tools.js

@@ -1,89 +1,89 @@
-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');
+
+// 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 };

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,
+};