stigmergy 1.0.94 → 1.0.97

package/src/core/cli_parameter_handler.js

@@ -0,0 +1,127 @@
+// 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,406 @@
+/**
+ * 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");
+const chalk = require("chalk");
+
+// 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 with enhanced formatting
+      const consoleMessage = `[${timestamp}] [${level}] [${errorType}] ${errorMessage}`;
+      const contextMessage = context ? `[CONTEXT] ${context}` : "";
+
+      switch (level) {
+        case LOG_LEVELS.ERROR:
+          console.error(chalk.red.bold(consoleMessage));
+          if (contextMessage) console.error(chalk.yellow(contextMessage));
+          if (error.stack) console.error(chalk.gray(error.stack));
+          break;
+        case LOG_LEVELS.WARN:
+          console.warn(chalk.yellow.bold(consoleMessage));
+          if (contextMessage) console.warn(chalk.yellow(contextMessage));
+          break;
+        case LOG_LEVELS.INFO:
+          console.info(chalk.blue(consoleMessage));
+          if (contextMessage) console.info(chalk.gray(contextMessage));
+          break;
+        case LOG_LEVELS.DEBUG:
+          console.debug(chalk.gray(consoleMessage));
+          if (contextMessage) console.debug(chalk.gray(contextMessage));
+          if (error.stack) console.debug(chalk.gray(error.stack));
+          break;
+        default:
+          console.log(chalk.white(consoleMessage));
+          if (contextMessage) console.log(chalk.gray(contextMessage));
+      }
+
+      // 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: {} };
+    }
+  }
+
+  /**
+   * Generate a formatted error report
+   * @param {Object} stats - Error statistics from getErrorStats()
+   * @returns {string} Formatted error report
+   */
+  generateErrorReport(stats) {
+    let report = "\n=== Stigmergy CLI Error Report ===\n";
+    report += `Total Errors: ${stats.totalErrors}\n\n`;
+
+    report += "Errors by Type:\n";
+    for (const [type, count] of Object.entries(stats.byType)) {
+      report += `  ${type}: ${count}\n`;
+    }
+
+    report += "\nErrors by Level:\n";
+    for (const [level, count] of Object.entries(stats.byLevel)) {
+      report += `  ${level}: ${count}\n`;
+    }
+
+    report += "==================================\n";
+    return report;
+  }
+
+  /**
+   * Print error report to console
+   */
+  async printErrorReport() {
+    const stats = await this.getErrorStats();
+    const report = this.generateErrorReport(stats);
+    console.log(report);
+  }
+}
+
+// Set up global error handlers within the error handler module
+function setupGlobalErrorHandlers() {
+  // Only set up handlers if they haven't been set up already
+  if (!process.listenerCount("unhandledRejection")) {
+    process.on("unhandledRejection", async (reason, promise) => {
+      console.error(
+        "[FATAL] Global Unhandled Rejection at:",
+        promise,
+        "reason:",
+        reason,
+      );
+
+      // Log the error using our error handler
+      const error =
+        reason instanceof Error ? reason : new Error(String(reason));
+      await errorHandler.logError(
+        error,
+        LOG_LEVELS.ERROR,
+        "global_unhandledRejection",
+      );
+
+      // Exit gracefully after a short delay to allow logging
+      setTimeout(() => process.exit(1), 100);
+    });
+  }
+
+  if (!process.listenerCount("uncaughtException")) {
+    process.on("uncaughtException", async (error) => {
+      console.error("[FATAL] Global Uncaught Exception:", error);
+
+      // Log the error using our error handler
+      await errorHandler.logError(
+        error,
+        LOG_LEVELS.ERROR,
+        "global_uncaughtException",
+      );
+
+      // Exit gracefully after a short delay to allow logging
+      setTimeout(() => process.exit(1), 100);
+    });
+  }
+}
+
+// Set up global handlers by default
+setupGlobalErrorHandlers();
+
+// Export singleton instance
+const errorHandler = new ErrorHandler();
+
+module.exports = {
+  ErrorHandler,
+  errorHandler,
+  StigmergyError,
+  ERROR_TYPES,
+  LOG_LEVELS,
+  setupGlobalErrorHandlers,
+};

package/src/core/memory_manager.js

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