stigmergy 1.0.93 → 1.0.95

package/src/core/cli_parameter_handler.js

@@ -0,0 +1,121 @@
+// 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;

package/src/core/cli_tools.js

@@ -0,0 +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 @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')
+    }
+};
+
+/**
+ * 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/error_handler.js

@@ -0,0 +1,307 @@
+/**
+ * Centralized Error Handling Utility for Stigmergy CLI
+ * Provides consistent error handling, logging, and reporting across the application
+ */
+
+const fs = require('fs/promises');
+const path = require('path');
+const os = require('os');
+
+// Error types enumeration
+const ERROR_TYPES = {
+  VALIDATION: 'VALIDATION_ERROR',
+  NETWORK: 'NETWORK_ERROR',
+  FILE_SYSTEM: 'FILE_SYSTEM_ERROR',
+  CLI_TOOL: 'CLI_TOOL_ERROR',
+  CONFIGURATION: 'CONFIGURATION_ERROR',
+  PERMISSION: 'PERMISSION_ERROR',
+  UNKNOWN: 'UNKNOWN_ERROR'
+};
+
+// Log levels enumeration
+const LOG_LEVELS = {
+  ERROR: 'ERROR',
+  WARN: 'WARN',
+  INFO: 'INFO',
+  DEBUG: 'DEBUG'
+};
+
+class StigmergyError extends Error {
+  constructor(message, type = ERROR_TYPES.UNKNOWN, code = null, details = null) {
+    super(message);
+    this.name = 'StigmergyError';
+    this.type = type;
+    this.code = code;
+    this.details = details;
+    this.timestamp = new Date().toISOString();
+    
+    // Ensure proper stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, StigmergyError);
+    }
+  }
+}
+
+class ErrorHandler {
+  constructor() {
+    this.logFile = path.join(os.homedir(), '.stigmergy', 'error.log');
+    this.maxLogSize = 10 * 1024 * 1024; // 10MB
+  }
+
+  /**
+   * Create a standardized Stigmergy error
+   * @param {string} message - Error message
+   * @param {string} type - Error type from ERROR_TYPES
+   * @param {string|null} code - Error code
+   * @param {Object|null} details - Additional error details
+   * @returns {StigmergyError}
+   */
+  createError(message, type = ERROR_TYPES.UNKNOWN, code = null, details = null) {
+    return new StigmergyError(message, type, code, details);
+  }
+
+  /**
+   * Log an error to console and file
+   * @param {Error|StigmergyError} error - The error to log
+   * @param {string} level - Log level (ERROR, WARN, INFO, DEBUG)
+   * @param {string|null} context - Context where error occurred
+   */
+  async logError(error, level = LOG_LEVELS.ERROR, context = null) {
+    try {
+      const timestamp = new Date().toISOString();
+      const errorType = error.type || ERROR_TYPES.UNKNOWN;
+      const errorCode = error.code || 'NO_CODE';
+      const errorMessage = error.message || 'Unknown error';
+      
+      // Format log entry
+      const logEntry = {
+        timestamp,
+        level,
+        type: errorType,
+        code: errorCode,
+        message: errorMessage,
+        context,
+        stack: error.stack || 'No stack trace available'
+      };
+
+      // Console output
+      const consoleMessage = `[${level}] [${errorType}] ${errorMessage}`;
+      switch (level) {
+        case LOG_LEVELS.ERROR:
+          console.error(consoleMessage);
+          break;
+        case LOG_LEVELS.WARN:
+          console.warn(consoleMessage);
+          break;
+        case LOG_LEVELS.INFO:
+          console.info(consoleMessage);
+          break;
+        case LOG_LEVELS.DEBUG:
+          console.debug(consoleMessage);
+          break;
+        default:
+          console.log(consoleMessage);
+      }
+
+      // File logging
+      await this.writeToFile(logEntry);
+    } catch (logError) {
+      console.error('[ERROR_HANDLER] Failed to log error:', logError.message);
+    }
+  }
+
+  /**
+   * Write error to log file
+   * @param {Object} logEntry - Formatted log entry
+   */
+  async writeToFile(logEntry) {
+    try {
+      // Ensure log directory exists
+      const logDir = path.dirname(this.logFile);
+      await fs.mkdir(logDir, { recursive: true });
+
+      // Check file size and rotate if necessary
+      await this.rotateLogFile();
+
+      // Append to log file
+      const logLine = JSON.stringify(logEntry) + '\n';
+      await fs.appendFile(this.logFile, logLine, { encoding: 'utf8' });
+    } catch (error) {
+      // Silent fail to prevent infinite loop
+    }
+  }
+
+  /**
+   * Rotate log file if it exceeds max size
+   */
+  async rotateLogFile() {
+    try {
+      const stats = await fs.stat(this.logFile);
+      if (stats.size > this.maxLogSize) {
+        const backupFile = this.logFile + '.old';
+        await fs.rename(this.logFile, backupFile);
+      }
+    } catch (error) {
+      // File doesn't exist or other issue, continue
+    }
+  }
+
+  /**
+   * Handle CLI tool execution errors
+   * @param {string} toolName - Name of the CLI tool
+   * @param {Error} error - Error that occurred
+   * @param {string|null} command - Command that failed
+   */
+  async handleCLIError(toolName, error, command = null) {
+    const cliError = new StigmergyError(
+      `Failed to execute ${toolName}${command ? ` command: ${command}` : ''}`,
+      ERROR_TYPES.CLI_TOOL,
+      null,
+      {
+        tool: toolName,
+        command,
+        originalError: error.message,
+        stack: error.stack
+      }
+    );
+
+    await this.logError(cliError, LOG_LEVELS.ERROR, 'CLI_EXECUTION');
+    return cliError;
+  }
+
+  /**
+   * Handle file system errors
+   * @param {string} operation - File operation that failed
+   * @param {string} filePath - Path of file involved
+   * @param {Error} error - Original error
+   */
+  async handleFileError(operation, filePath, error) {
+    const fileError = new StigmergyError(
+      `Failed to ${operation} file: ${filePath}`,
+      ERROR_TYPES.FILE_SYSTEM,
+      error.code,
+      {
+        operation,
+        filePath,
+        originalError: error.message,
+        stack: error.stack
+      }
+    );
+
+    await this.logError(fileError, LOG_LEVELS.ERROR, 'FILE_SYSTEM');
+    return fileError;
+  }
+
+  /**
+   * Handle network errors
+   * @param {string} operation - Network operation that failed
+   * @param {string} url - URL involved
+   * @param {Error} error - Original error
+   */
+  async handleNetworkError(operation, url, error) {
+    const networkError = new StigmergyError(
+      `Network error during ${operation}: ${url}`,
+      ERROR_TYPES.NETWORK,
+      error.code,
+      {
+        operation,
+        url,
+        originalError: error.message,
+        stack: error.stack
+      }
+    );
+
+    await this.logError(networkError, LOG_LEVELS.ERROR, 'NETWORK');
+    return networkError;
+  }
+
+  /**
+   * Handle validation errors
+   * @param {string} field - Field that failed validation
+   * @param {string} value - Value that failed validation
+   * @param {string} reason - Reason for validation failure
+   */
+  createValidationError(field, value, reason) {
+    const validationError = new StigmergyError(
+      `Validation failed for ${field}: ${reason}`,
+      ERROR_TYPES.VALIDATION,
+      'VALIDATION_FAILED',
+      {
+        field,
+        value,
+        reason
+      }
+    );
+
+    return validationError;
+  }
+
+  /**
+   * Wrap an async function with error handling
+   * @param {Function} fn - Async function to wrap
+   * @param {string} context - Context for error logging
+   * @returns {Function} Wrapped function
+   */
+  wrapAsync(fn, context) {
+    return async (...args) => {
+      try {
+        return await fn(...args);
+      } catch (error) {
+        if (error instanceof StigmergyError) {
+          await this.logError(error, LOG_LEVELS.ERROR, context);
+          throw error;
+        } else {
+          const wrappedError = new StigmergyError(
+            error.message || 'Unknown error occurred',
+            ERROR_TYPES.UNKNOWN,
+            null,
+            { originalError: error.message, stack: error.stack }
+          );
+          await this.logError(wrappedError, LOG_LEVELS.ERROR, context);
+          throw wrappedError;
+        }
+      }
+    };
+  }
+
+  /**
+   * Get error statistics from log file
+   */
+  async getErrorStats() {
+    try {
+      const data = await fs.readFile(this.logFile, 'utf8');
+      const lines = data.split('\n').filter(line => line.trim());
+      
+      const stats = {
+        totalErrors: lines.length,
+        byType: {},
+        byLevel: {}
+      };
+
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          stats.byType[entry.type] = (stats.byType[entry.type] || 0) + 1;
+          stats.byLevel[entry.level] = (stats.byLevel[entry.level] || 0) + 1;
+        } catch (parseError) {
+          // Skip malformed entries
+        }
+      }
+
+      return stats;
+    } catch (error) {
+      return { totalErrors: 0, byType: {}, byLevel: {} };
+    }
+  }
+}
+
+// Export singleton instance
+const errorHandler = new ErrorHandler();
+
+module.exports = {
+  ErrorHandler,
+  errorHandler,
+  StigmergyError,
+  ERROR_TYPES,
+  LOG_LEVELS
+};

package/src/core/memory_manager.js

@@ -0,0 +1,76 @@
+// src/core/memory_manager.js
+
+const fs = require('fs/promises');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Memory Manager - Handles global memory and context sharing between CLI tools
+ */
+class MemoryManager {
+    constructor() {
+        this.globalMemoryFile = path.join(os.homedir(), '.stigmergy', 'memory.json');
+        this.projectMemoryFile = path.join(process.cwd(), 'STIGMERGY.md');
+    }
+
+    /**
+     * Get global memory data
+     * @returns {Promise<Object>} Memory data
+     */
+    async getGlobalMemory() {
+        try {
+            const data = await fs.readFile(this.globalMemoryFile, 'utf8');
+            return JSON.parse(data);
+        } catch (error) {
+            // Return default memory structure if file doesn't exist or is invalid
+            return {
+                version: '1.0.0',
+                lastUpdated: new Date().toISOString(),
+                interactions: [],
+                collaborations: []
+            };
+        }
+    }
+
+    /**
+     * Update global memory data
+     * @param {Function} updateFn - Function that takes current memory and returns updated memory
+     * @returns {Promise<Object>} Updated memory data
+     */
+    async updateGlobalMemory(updateFn) {
+        const memory = await this.getGlobalMemory();
+        const updatedMemory = updateFn(memory);
+        updatedMemory.lastUpdated = new Date().toISOString();
+        
+        // Ensure directory exists
+        const dir = path.dirname(this.globalMemoryFile);
+        await fs.mkdir(dir, { recursive: true });
+        
+        // Write updated memory
+        await fs.writeFile(this.globalMemoryFile, JSON.stringify(updatedMemory, null, 2));
+        return updatedMemory;
+    }
+
+    /**
+     * Add an interaction record to memory
+     * @param {string} tool - CLI tool name
+     * @param {string} prompt - User prompt
+     * @param {string} response - Tool response
+     * @param {number} duration - Execution duration in milliseconds
+     * @returns {Promise<void>}
+     */
+    async addInteraction(tool, prompt, response, duration = 0) {
+        await this.updateGlobalMemory(memory => {
+            memory.interactions.push({
+                timestamp: new Date().toISOString(),
+                tool,
+                prompt,
+                response,
+                duration
+            });
+            return memory;
+        });
+    }
+}
+
+module.exports = MemoryManager;