stigmergy 1.0.94 → 1.0.97

package/src/core/rest_client.js

@@ -0,0 +1,160 @@
+/**
+ * Simple REST API Client
+ * Provides basic HTTP methods for interacting with REST APIs
+ */
+
+class RestClient {
+  /**
+   * Create a new REST client
+   * @param {string} baseURL - The base URL for API requests
+   * @param {Object} defaultHeaders - Default headers to include in all requests
+   */
+  constructor(baseURL = "", defaultHeaders = {}) {
+    this.baseURL = baseURL;
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      ...defaultHeaders,
+    };
+  }
+
+  /**
+   * Make an HTTP request
+   * @param {string} method - HTTP method (GET, POST, PUT, DELETE, etc.)
+   * @param {string} url - Request URL (will be appended to baseURL)
+   * @param {Object} options - Request options
+   * @returns {Promise<Object>} Response data
+   */
+  async request(method, url, options = {}) {
+    const { headers = {}, body = null, params = {}, timeout = 10000 } = options;
+
+    // Construct full URL
+    let fullURL = this.baseURL + url;
+
+    // Add query parameters
+    if (Object.keys(params).length > 0) {
+      const queryParams = new URLSearchParams(params);
+      fullURL += (fullURL.includes("?") ? "&" : "?") + queryParams.toString();
+    }
+
+    // Merge headers
+    const mergedHeaders = {
+      ...this.defaultHeaders,
+      ...headers,
+    };
+
+    // Prepare fetch options
+    const fetchOptions = {
+      method,
+      headers: mergedHeaders,
+      timeout,
+    };
+
+    // Add body for methods that support it
+    if (body && ["POST", "PUT", "PATCH", "DELETE"].includes(method)) {
+      fetchOptions.body =
+        typeof body === "object" ? JSON.stringify(body) : body;
+    }
+
+    try {
+      const response = await fetch(fullURL, fetchOptions);
+      const contentType = response.headers.get("content-type");
+
+      let data;
+      if (contentType && contentType.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        data,
+      };
+    } catch (error) {
+      throw new Error(`Request failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Make a GET request
+   * @param {string} url - Request URL
+   * @param {Object} options - Request options
+   * @returns {Promise<Object>} Response data
+   */
+  async get(url, options = {}) {
+    return this.request("GET", url, options);
+  }
+
+  /**
+   * Make a POST request
+   * @param {string} url - Request URL
+   * @param {Object} data - Data to send in request body
+   * @param {Object} options - Request options
+   * @returns {Promise<Object>} Response data
+   */
+  async post(url, data, options = {}) {
+    return this.request("POST", url, { ...options, body: data });
+  }
+
+  /**
+   * Make a PUT request
+   * @param {string} url - Request URL
+   * @param {Object} data - Data to send in request body
+   * @param {Object} options - Request options
+   * @returns {Promise<Object>} Response data
+   */
+  async put(url, data, options = {}) {
+    return this.request("PUT", url, { ...options, body: data });
+  }
+
+  /**
+   * Make a PATCH request
+   * @param {string} url - Request URL
+   * @param {Object} data - Data to send in request body
+   * @param {Object} options - Request options
+   * @returns {Promise<Object>} Response data
+   */
+  async patch(url, data, options = {}) {
+    return this.request("PATCH", url, { ...options, body: data });
+  }
+
+  /**
+   * Make a DELETE request
+   * @param {string} url - Request URL
+   * @param {Object} options - Request options
+   * @returns {Promise<Object>} Response data
+   */
+  async delete(url, options = {}) {
+    return this.request("DELETE", url, options);
+  }
+
+  /**
+   * Set default headers
+   * @param {Object} headers - Headers to set as default
+   */
+  setDefaultHeaders(headers) {
+    this.defaultHeaders = {
+      ...this.defaultHeaders,
+      ...headers,
+    };
+  }
+
+  /**
+   * Set authorization header
+   * @param {string} token - Authorization token
+   * @param {string} type - Authorization type (Bearer, Basic, etc.)
+   */
+  setAuthorization(token, type = "Bearer") {
+    this.setDefaultHeaders({
+      Authorization: `${type} ${token}`,
+    });
+  }
+}
+
+module.exports = RestClient;

package/src/core/smart_router.js

@@ -0,0 +1,146 @@
+const CLIHelpAnalyzer = require("./cli_help_analyzer");
+const { CLI_TOOLS, validateCLITool } = require("./cli_tools");
+const { errorHandler, ERROR_TYPES } = require("./error_handler");
+
+class SmartRouter {
+  constructor() {
+    this.tools = CLI_TOOLS;
+    try {
+      this.analyzer = new CLIHelpAnalyzer();
+      this.analyzer.setCLITools(this.tools);
+    } catch (error) {
+      errorHandler.logError(error, "ERROR", "SmartRouter.constructor");
+      throw error;
+    }
+    this.routeKeywords = [
+      "use",
+      "help",
+      "please",
+      "write",
+      "generate",
+      "explain",
+      "analyze",
+      "translate",
+      "code",
+      "article",
+    ];
+    this.defaultTool = "claude";
+  }
+
+  /**
+   * Initialize the smart router
+   */
+  async initialize() {
+    await this.analyzer.initialize();
+  }
+
+  /**
+   * Check if input should be routed to a specific CLI tool
+   */
+  shouldRoute(userInput) {
+    return this.routeKeywords.some((keyword) =>
+      userInput.toLowerCase().includes(keyword.toLowerCase()),
+    );
+  }
+
+  /**
+   * Perform smart routing based on user input and CLI patterns
+   */
+  async smartRoute(userInput) {
+    const input = userInput.trim();
+
+    // First try to detect tool-specific keywords
+    for (const [toolName, toolInfo] of Object.entries(this.tools)) {
+      try {
+        // Validate tool configuration
+        validateCLITool(toolName);
+
+        // Get CLI pattern for this tool
+        let cliPattern = await this.analyzer.getCLIPattern(toolName);
+
+        // If we don't have a pattern, try to analyze the CLI
+        if (!cliPattern) {
+          try {
+            cliPattern = await this.analyzer.analyzeCLI(toolName);
+          } catch (error) {
+            console.warn(`Failed to analyze ${toolName}:`, error.message);
+            // Continue with next tool
+            continue;
+          }
+        }
+
+        // Check if input contains any of the tool's keywords or subcommands
+        const keywords = this.extractKeywords(toolName, cliPattern);
+        for (const keyword of keywords) {
+          if (input.toLowerCase().includes(keyword.toLowerCase())) {
+            // Extract clean parameters
+            const cleanInput = input
+              .replace(new RegExp(`.*${keyword}\\s*`, "gi"), "")
+              .replace(/^(use|please|help|using|with)\s*/i, "")
+              .trim();
+            return { tool: toolName, prompt: cleanInput };
+          }
+        }
+      } catch (error) {
+        await errorHandler.logError(
+          error,
+          "WARN",
+          `SmartRouter.smartRoute.${toolName}`,
+        );
+        // Continue with next tool
+        continue;
+      }
+    }
+
+    // Default routing
+    const cleanInput = input
+      .replace(/^(use|please|help|using|with)\s*/i, "")
+      .trim();
+    return { tool: this.defaultTool, prompt: cleanInput };
+  }
+
+  /**
+   * Extract keywords for a tool from its CLI patterns
+   */
+  extractKeywords(toolName, cliPattern) {
+    const keywords = [toolName];
+
+    // Add tool-specific keywords
+    const toolSpecificKeywords = {
+      claude: ["claude", "anthropic"],
+      gemini: ["gemini", "google"],
+      qwen: ["qwen", "alibaba", "tongyi"],
+      iflow: ["iflow", "workflow", "intelligent"],
+      qodercli: ["qoder", "code"],
+      codebuddy: ["codebuddy", "buddy", "assistant"],
+      copilot: ["copilot", "github", "gh"],
+      codex: ["codex", "openai", "gpt"],
+    };
+
+    if (toolSpecificKeywords[toolName]) {
+      keywords.push(...toolSpecificKeywords[toolName]);
+    }
+
+    // Add subcommands from CLI pattern if available
+    if (cliPattern && cliPattern.patterns && cliPattern.patterns.subcommands) {
+      cliPattern.patterns.subcommands.forEach((subcommand) => {
+        if (subcommand.name) {
+          keywords.push(subcommand.name);
+        }
+      });
+    }
+
+    // Add commands from CLI pattern if available
+    if (cliPattern && cliPattern.patterns && cliPattern.patterns.commands) {
+      cliPattern.patterns.commands.forEach((command) => {
+        if (command.name && command.name !== toolName) {
+          keywords.push(command.name);
+        }
+      });
+    }
+
+    return [...new Set(keywords)]; // Remove duplicates
+  }
+}
+
+module.exports = SmartRouter;

package/src/data_encryption.js

@@ -0,0 +1,143 @@
+/**
+ * Data encryption utilities for the Stigmergy CLI
+ * Provides secure data encryption and decryption functions using AES-256-GCM
+ */
+
+const crypto = require("crypto");
+
+/**
+ * Encrypts data using AES-256-GCM authenticated encryption
+ *
+ * This function provides secure symmetric encryption with authentication.
+ * It generates a random initialization vector for each encryption operation
+ * and returns the encrypted data along with the IV and authentication tag.
+ *
+ * @param {string|Buffer} data - The plaintext data to encrypt
+ * @param {string|Buffer} secretKey - The secret key for encryption (must be 32 bytes for AES-256)
+ * @returns {Object} Object containing encrypted data, IV, and authentication tag
+ * @throws {Error} If encryption fails due to invalid inputs or cryptographic errors
+ *
+ * @example
+ * const crypto = require('crypto');
+ * const secretKey = crypto.randomBytes(32); // 256-bit key
+ * const plaintext = "Secret message";
+ * const encryptedObj = encryptData(plaintext, secretKey);
+ * console.log(encryptedObj);
+ * // Output: {
+ * //   encryptedData: 'a3f5b7c8...',
+ * //   iv: 'MjRkOGZj...',
+ * //   authTag: 'YzQyNTgx...'
+ * // }
+ */
+function encryptData(data, secretKey) {
+  // Validate inputs
+  if (!data) {
+    throw new Error("Data to encrypt cannot be empty");
+  }
+
+  if (!secretKey) {
+    throw new Error("Secret key is required");
+  }
+
+  // Generate a random initialization vector
+  const iv = crypto.randomBytes(16);
+
+  // Create cipher using AES-256-GCM
+  const cipher = crypto.createCipherGCM("aes-256-gcm", secretKey, iv);
+
+  // Encrypt the data
+  let encrypted;
+  if (typeof data === "string") {
+    encrypted = cipher.update(data, "utf8", "hex");
+  } else {
+    encrypted = cipher.update(data);
+    encrypted = encrypted.toString("hex");
+  }
+  cipher.final();
+
+  // Get the authentication tag
+  const authTag = cipher.getAuthTag();
+
+  // Return encrypted data with IV and auth tag
+  return {
+    encryptedData: encrypted,
+    iv: iv.toString("base64"),
+    authTag: authTag.toString("base64"),
+  };
+}
+
+/**
+ * Decrypts data using AES-256-GCM authenticated decryption
+ *
+ * This function decrypts data that was encrypted with encryptData().
+ * It requires the encrypted data object containing the encrypted data,
+ * initialization vector, and authentication tag.
+ *
+ * @param {Object} encryptedObj - Object containing encrypted data, IV, and auth tag
+ * @param {string|Buffer} secretKey - The secret key used for encryption
+ * @returns {string} The decrypted plaintext data
+ * @throws {Error} If decryption fails due to invalid inputs, tampered data, or cryptographic errors
+ *
+ * @example
+ * const decrypted = decryptData(encryptedObj, secretKey);
+ * console.log(decrypted); // "Secret message"
+ */
+function decryptData(encryptedObj, secretKey) {
+  // Validate inputs
+  if (
+    !encryptedObj ||
+    !encryptedObj.encryptedData ||
+    !encryptedObj.iv ||
+    !encryptedObj.authTag
+  ) {
+    throw new Error("Invalid encrypted object");
+  }
+
+  if (!secretKey) {
+    throw new Error("Secret key is required");
+  }
+
+  // Decode base64 encoded values
+  const iv = Buffer.from(encryptedObj.iv, "base64");
+  const authTag = Buffer.from(encryptedObj.authTag, "base64");
+
+  // Create decipher using AES-256-GCM
+  const decipher = crypto.createDecipherGCM("aes-256-gcm", secretKey, iv);
+
+  // Set the authentication tag
+  decipher.setAuthTag(authTag);
+
+  // Decrypt the data
+  let decrypted;
+  if (typeof encryptedObj.encryptedData === "string") {
+    decrypted = decipher.update(encryptedObj.encryptedData, "hex", "utf8");
+  } else {
+    decrypted = decipher.update(encryptedObj.encryptedData);
+    decrypted = decrypted.toString("utf8");
+  }
+  decipher.final();
+
+  return decrypted;
+}
+
+/**
+ * Generates a cryptographically secure random key
+ *
+ * This function generates a random key suitable for AES-256 encryption.
+ *
+ * @param {number} [length=32] - Length of the key in bytes (32 bytes = 256 bits)
+ * @returns {Buffer} A cryptographically secure random key
+ *
+ * @example
+ * const key = generateKey(); // 32-byte key for AES-256
+ * const shortKey = generateKey(16); // 16-byte key for AES-128
+ */
+function generateKey(length = 32) {
+  return crypto.randomBytes(length);
+}
+
+module.exports = {
+  encryptData,
+  decryptData,
+  generateKey,
+};