stigmergy 1.0.95 → 1.0.97

package/src/core/cli_parameter_handler.js

@@ -1,121 +1,127 @@
 // Unified CLI Parameter Handler
-const { spawn } = require('child_process');
+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 = [];
+  /**
+   * 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}"`];
-        }
+    // 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);
-        }
+    try {
+      // Check if we have pattern information from CLI help analyzer
+      if (cliPattern && cliPattern.commandStructure) {
+        const commandStructure = cliPattern.commandStructure;
 
-        return toolArgs;
+        // 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);
     }
 
-    /**
-     * 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 toolArgs;
+  }
 
-        // Return tool-specific arguments if available
-        if (toolSpecificArgs[toolName]) {
-            return toolSpecificArgs[toolName];
-        }
+  /**
+   * 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
+    };
 
-        // 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}"`];
-        }
+    // Return tool-specific arguments if available
+    if (toolSpecificArgs[toolName]) {
+      return toolSpecificArgs[toolName];
+    }
 
-        // Default to argument-based approach
-        return [`"${prompt}"`];
+    // 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}"`];
     }
 
-    /**
-     * 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);
+    // Default to argument-based approach
+    return [`"${prompt}"`];
+  }
 
-        // Execute the tool
-        const child = spawn(toolPath, toolArgs, {
-            stdio: 'inherit',
-            shell: true
-        });
+  /**
+   * 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);
 
-        return child;
-    }
+    // Execute the tool
+    const child = spawn(toolPath, toolArgs, {
+      stdio: "inherit",
+      shell: true,
+    });
+
+    return child;
+  }
 }
 
-module.exports = CLIParameterHandler;
+module.exports = CLIParameterHandler;

package/src/core/cli_tools.js

@@ -1,65 +1,65 @@
-const path = require('path');
-const os = require('os');
-const { errorHandler, ERROR_TYPES } = require('./error_handler');
+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 @alibaba/qwen-cli',
-        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')
-    }
+  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 @alibaba/qwen-cli",
+    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"),
+  },
 };
 
 /**
@@ -68,22 +68,22 @@ const CLI_TOOLS = {
  * @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'
-        );
-    }
+  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 };
+module.exports = { CLI_TOOLS, validateCLITool };