@ideascol/agents-generator-sdk 0.0.1

package/dist/bin/cli.js

@@ -0,0 +1,1077 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// node_modules/@ideascol/cli-maker/dist/colors.js
+var require_colors = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.Colors = undefined;
+  exports2.Colors = {
+    Reset: "\x1B[0m",
+    Bright: "\x1B[1m",
+    Dim: "\x1B[2m",
+    Underscore: "\x1B[4m",
+    Blink: "\x1B[5m",
+    Reverse: "\x1B[7m",
+    Hidden: "\x1B[8m",
+    FgBlack: "\x1B[30m",
+    FgRed: "\x1B[31m",
+    FgGreen: "\x1B[32m",
+    FgYellow: "\x1B[33m",
+    FgBlue: "\x1B[34m",
+    FgMagenta: "\x1B[35m",
+    FgCyan: "\x1B[36m",
+    FgWhite: "\x1B[37m",
+    FgGray: "\x1B[90m",
+    BgBlack: "\x1B[40m",
+    BgRed: "\x1B[41m",
+    BgGreen: "\x1B[42m",
+    BgYellow: "\x1B[43m",
+    BgBlue: "\x1B[44m",
+    BgMagenta: "\x1B[45m",
+    BgCyan: "\x1B[46m",
+    BgWhite: "\x1B[47m"
+  };
+});
+
+// node_modules/@ideascol/cli-maker/dist/interfaces.js
+var require_interfaces = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.ParamType = undefined;
+  var ParamType;
+  (function(ParamType2) {
+    ParamType2["Text"] = "text";
+    ParamType2["Number"] = "number";
+    ParamType2["Custom"] = "custom";
+    ParamType2["List"] = "list";
+    ParamType2["Boolean"] = "boolean";
+    ParamType2["Email"] = "email";
+    ParamType2["Phone"] = "phone";
+    ParamType2["Url"] = "url";
+    ParamType2["Package"] = "Package";
+  })(ParamType || (exports2.ParamType = ParamType = {}));
+});
+
+// node_modules/@ideascol/cli-maker/dist/command/validator.js
+var require_validator = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.Validator = undefined;
+  var colors_1 = require_colors();
+  var interfaces_1 = require_interfaces();
+
+  class Validator {
+    validateParam(value, type, isRequired, options, paramName) {
+      if (this.checkEmpty(value) && isRequired) {
+        return { error: `${colors_1.Colors.FgRed}Missing required parameter${paramName ? `: ${paramName}` : ""}${colors_1.Colors.Reset}` };
+      } else if (this.checkEmpty(value) && !isRequired) {
+        return { value: undefined, error: "" };
+      }
+      if (value === undefined) {
+        return { value };
+      }
+      switch (type) {
+        case interfaces_1.ParamType.Number:
+          if (!/^[0-9]+$/.test(value)) {
+            return { error: `${colors_1.Colors.FgRed}Invalid number:${colors_1.Colors.Reset} ${value}` };
+          }
+          return { value: Number(value) };
+        case interfaces_1.ParamType.Custom:
+          try {
+            const customValue = JSON.parse(value);
+            if (Array.isArray(customValue) || typeof customValue === "object") {
+              return { value: customValue };
+            } else {
+              return { error: `${colors_1.Colors.FgRed}Invalid custom value:${colors_1.Colors.Reset} ${value}` };
+            }
+          } catch {
+            return { error: `${colors_1.Colors.FgRed}Invalid custom value:${colors_1.Colors.Reset} ${value}` };
+          }
+        case interfaces_1.ParamType.List:
+          if (options === undefined || options?.length === 0) {
+            return { error: `${colors_1.Colors.FgRed}Invalid List:${colors_1.Colors.Reset} empty options`, value: undefined };
+          }
+          const foundValue = options?.filter((x) => x === value);
+          if (foundValue?.length === 0) {
+            return { error: `${colors_1.Colors.FgRed}Invalid List:${colors_1.Colors.Reset} ${value} doesn't exists`, value: undefined };
+          }
+          return { value };
+        case interfaces_1.ParamType.Boolean:
+          if (value.toLowerCase() !== "true" && value.toLowerCase() !== "false") {
+            return { error: `${colors_1.Colors.FgRed}Invalid boolean:${colors_1.Colors.Reset} ${value}` };
+          }
+          return { value: value.toLowerCase() === "true" };
+        case interfaces_1.ParamType.Email:
+          if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+            return { error: `${colors_1.Colors.FgRed}Invalid email:${colors_1.Colors.Reset} ${value}` };
+          }
+          return { value };
+        case interfaces_1.ParamType.Url:
+          if (!/^https?:\/\/.+$/.test(value)) {
+            return { error: `${colors_1.Colors.FgRed}Invalid URL:${colors_1.Colors.Reset} ${value}` };
+          }
+          return { value };
+        case interfaces_1.ParamType.Package:
+          if (!/^@[a-zA-Z0-9-]+\/[a-zA-Z0-9-]+$/.test(value)) {
+            return { error: `${colors_1.Colors.FgRed}the format of the package is not correct, @company/package-name${colors_1.Colors.Reset}` };
+          }
+          return { value };
+        default:
+          return { value };
+      }
+    }
+    checkEmpty(value) {
+      return value === undefined || value === "" || value === null;
+    }
+  }
+  exports2.Validator = Validator;
+});
+
+// node_modules/@ideascol/cli-maker/dist/command/command.js
+var require_command = __commonJS((exports2) => {
+  var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.CLI = undefined;
+  var readline_1 = __importDefault(require("readline"));
+  var colors_1 = require_colors();
+  var interfaces_1 = require_interfaces();
+  var validator_1 = require_validator();
+
+  class CLI {
+    constructor(name, description, options) {
+      this.name = name;
+      this.description = description;
+      this.options = options;
+      this.commands = [];
+      if (this.options == null) {
+        this.options = { interactive: true, version: "1.0.0" };
+      }
+      this.validator = new validator_1.Validator;
+    }
+    getCommands() {
+      return this.commands;
+    }
+    getName() {
+      return this.name;
+    }
+    getDescription() {
+      return this.description;
+    }
+    getOptions() {
+      return this.options;
+    }
+    command(command) {
+      this.commands.push(command);
+    }
+    setOptions(options) {
+      this.options = options;
+    }
+    parse(argv) {
+      const [nodePath, scriptPath, ...args] = argv;
+      const commandName = args[0];
+      if (!commandName || commandName === "--version") {
+        if (commandName === "--version") {
+          console.log(`
+${colors_1.Colors.FgGreen}${this.name} version: ${this.options?.version}${colors_1.Colors.Reset}
+`);
+        } else {
+          this.help();
+        }
+        return;
+      }
+      const command = this.findCommand(commandName);
+      if (!command) {
+        this.showUnknownCommandError(commandName);
+        return;
+      }
+      if (args.includes("--help")) {
+        this.commandHelp(command);
+        return;
+      }
+      const params = this.parseArgs(args.slice(1), command);
+      if (params.error) {
+        console.log(`
+${params.error}`);
+        process.exit(1);
+      }
+      if (Object.keys(params.result).length > 0) {
+        if (this.options.interactive) {
+          this.options.interactive = false;
+        }
+      }
+      const missingParams = this.getMissingParams(command, params.result);
+      if (missingParams.length > 0 && this.options?.interactive) {
+        this.handleMissingParams(command.params, params.result, command);
+      } else {
+        if (missingParams.length > 0) {
+          console.log(`
+${colors_1.Colors.FgRed}error missing params${colors_1.Colors.Reset}
+`);
+          missingParams.map((param) => {
+            console.log(`> ${colors_1.Colors.FgRed}${param.name}${colors_1.Colors.Reset}`);
+            console.log(`  > ${colors_1.Colors.FgGray}Type: ${param.type}${colors_1.Colors.Reset}`);
+            console.log(`  > ${colors_1.Colors.FgGray}Description: ${param.description}${colors_1.Colors.Reset}`);
+            if (param.options) {
+              console.log(`  > ${colors_1.Colors.FgGray}Options: ${param.options}${colors_1.Colors.Reset}`);
+            }
+          });
+          console.log(`
+${colors_1.Colors.FgYellow}Optional missing params${colors_1.Colors.Reset}
+`);
+          this.getOptionalParams(command, params.result).map((param) => {
+            console.log(`> ${colors_1.Colors.FgYellow}${param.name}${colors_1.Colors.Reset}`);
+            console.log(`  > ${colors_1.Colors.FgGray}Type: ${param.type}${colors_1.Colors.Reset}`);
+            console.log(`  > ${colors_1.Colors.FgGray}Description: ${param.description}${colors_1.Colors.Reset}`);
+            if (param.options) {
+              console.log(`  > ${colors_1.Colors.FgGray}Options: ${param.options}${colors_1.Colors.Reset}`);
+            }
+          });
+          process.exit(1);
+        }
+        command.action(params.result);
+      }
+    }
+    help() {
+      console.log("");
+      console.log(`${colors_1.Colors.Bright}Welcome to ${colors_1.Colors.FgGreen}${this.name}${colors_1.Colors.Reset}`);
+      console.log("");
+      console.log(`${colors_1.Colors.FgYellow}${this.description}${colors_1.Colors.Reset}`);
+      console.log("");
+      console.log(`${colors_1.Colors.Bright}Available commands:${colors_1.Colors.Reset}`);
+      this.commands.forEach((cmd) => {
+        console.log(`${colors_1.Colors.FgGreen}  ${cmd.name}${colors_1.Colors.Reset}: ${cmd.description}`);
+      });
+      console.log("");
+    }
+    commandHelp(command) {
+      console.log(`${colors_1.Colors.Bright}Help for command: ${colors_1.Colors.FgGreen}${command.name}${colors_1.Colors.Reset}`);
+      console.log(`${colors_1.Colors.FgGreen}Description:${colors_1.Colors.Reset} ${command.description}`);
+      if (command.params.length > 0) {
+        console.log(`${colors_1.Colors.FgGreen}Parameters:${colors_1.Colors.Reset}`);
+        command.params.forEach((param) => {
+          console.log(`${colors_1.Colors.FgYellow}(${param.type}) ${colors_1.Colors.Reset}${colors_1.Colors.FgGreen}${param.name}${colors_1.Colors.Reset}: ${param.description} ${param.required ? "(required)" : ""}`);
+        });
+      }
+    }
+    findCommand(commandName) {
+      return this.commands.find((cmd) => cmd.name === commandName);
+    }
+    showUnknownCommandError(commandName) {
+      console.log(`${colors_1.Colors.FgRed}Unknown command: ${commandName}${colors_1.Colors.Reset}`);
+      this.help();
+    }
+    getMissingParams(command, result) {
+      const requiredParams = command.params.filter((p) => p.required === true);
+      return requiredParams.filter((p) => result[p.name] === undefined);
+    }
+    getOptionalParams(command, result) {
+      const optionalParams = command.params.filter((p) => p.required === false || p.required === undefined);
+      return optionalParams.filter((p) => result[p.name] === undefined);
+    }
+    handleMissingParams(missingParams, result, command) {
+      if (this.options.interactive) {
+        this.promptForMissingParams(missingParams, result).then((fullParams) => {
+          command.action(fullParams);
+        });
+      } else {
+        console.log(`${colors_1.Colors.FgRed}Missing required parameters:${colors_1.Colors.Reset} ${missingParams.map((p) => p.name).join(", ")}`);
+        process.exit(1);
+      }
+    }
+    parseArgs(args, command) {
+      const result = {};
+      for (const arg of args) {
+        const [key, value] = arg.split("=");
+        if (key.startsWith("--")) {
+          const paramName = key.slice(2);
+          const commandParam = command.params.find((p) => p.name === paramName);
+          if (commandParam) {
+            const validation = this.validateParam(value, commandParam.type, commandParam.required, commandParam.options, paramName);
+            if (validation.error) {
+              return { error: validation.error };
+            }
+            result[paramName] = validation.value;
+          } else {
+            return { error: `
+Param ${colors_1.Colors.FgRed}${paramName}${colors_1.Colors.Reset} ${colors_1.Colors.Bright}is not allowed${colors_1.Colors.Reset}` };
+          }
+        }
+      }
+      return { result };
+    }
+    validateParam(value, type, isRequired, options, paramName) {
+      return this.validator.validateParam(value, type, isRequired, options, paramName);
+    }
+    findParamType(paramName) {
+      return this.commands.flatMap((command) => command.params).find((param) => param.name === paramName);
+    }
+    async promptForMissingParams(missingParams, existingParams) {
+      const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const askQuestion = (question) => {
+        return new Promise((resolve) => rl.question(question, resolve));
+      };
+      const prompts = missingParams.reduce((promise, param) => {
+        return promise.then(async (answers) => {
+          let answer;
+          let validation;
+          if (param.type === interfaces_1.ParamType.List && param.options) {
+            const isRequired = param.required ? "(required) " : "";
+            console.log(`
+${colors_1.Colors.FgYellow}(${param.type}) ${colors_1.Colors.Reset}${colors_1.Colors.FgGreen}${param.name}${colors_1.Colors.Reset} `);
+            console.log(`${colors_1.Colors.FgYellow}> ${colors_1.Colors.Reset}${colors_1.Colors.FgGray}${isRequired}${param.description}:${colors_1.Colors.Reset}
+`);
+            answer = await this.promptWithArrows(param);
+            validation = { value: param.options[parseInt(answer, 10)] };
+          } else {
+            do {
+              const isRequired = param.required ? "(required) " : "(Enter to skip) ";
+              const message = `
+${colors_1.Colors.FgYellow}(${param.type}) ${colors_1.Colors.Reset}${colors_1.Colors.FgGreen}${param.name}${colors_1.Colors.Reset}
+${colors_1.Colors.FgYellow}> ${colors_1.Colors.Reset}${colors_1.Colors.FgGray}${isRequired}${param.description}:${colors_1.Colors.Reset}
+`;
+              answer = await askQuestion(message);
+              validation = this.validateParam(answer, param.type, param.required, param.options);
+              if (validation.error) {
+                console.log(validation.error);
+              }
+            } while (validation.error);
+          }
+          return { ...answers, [param.name]: validation.value };
+        });
+      }, Promise.resolve(existingParams));
+      return prompts.finally(() => rl.close());
+    }
+    async promptWithArrows(param) {
+      return new Promise((resolve) => {
+        let index = 0;
+        const options = param.options;
+        const renderOptions = () => {
+          options.forEach((option, i) => {
+            process.stdout.write("\x1B[2K\x1B[0G");
+            if (i === index) {
+              process.stdout.write(`${colors_1.Colors.FgGreen}> ${option}${colors_1.Colors.Reset}
+`);
+            } else {
+              process.stdout.write(`  ${option}
+`);
+            }
+          });
+          process.stdout.write(`\x1B[${options.length}A`);
+        };
+        const clearLines = (numLines) => {
+          for (let i = 0;i < numLines; i++) {
+            process.stdout.write("\x1B[2K\x1B[1A");
+          }
+          process.stdout.write("\x1B[2K\x1B[0G");
+        };
+        const keypressHandler = (str, key) => {
+          if (key.name === "up") {
+            index = index > 0 ? index - 1 : options.length - 1;
+            renderOptions();
+          } else if (key.name === "down") {
+            index = (index + 1) % options.length;
+            renderOptions();
+          } else if (key.name === "return") {
+            process.stdin.removeListener("keypress", keypressHandler);
+            clearLines(options.length);
+            options.forEach((option, i) => {
+              if (i === index) {
+                process.stdout.write(`${colors_1.Colors.FgGreen}> ${option}${colors_1.Colors.Reset}
+`);
+              } else {
+                process.stdout.write(`  ${option}
+`);
+              }
+            });
+            process.stdout.write(`
+Selected: ${options[index]}
+`);
+            resolve(index.toString());
+            return;
+          }
+        };
+        readline_1.default.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(true);
+        }
+        process.stdin.on("keypress", keypressHandler);
+        renderOptions();
+      });
+    }
+  }
+  exports2.CLI = CLI;
+});
+
+// node_modules/@ideascol/cli-maker/dist/common.js
+var require_common = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.stripAnsiCodes = stripAnsiCodes;
+  function stripAnsiCodes(str) {
+    return str.replace(/[\u001b\u009b][[\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+  }
+});
+
+// node_modules/@ideascol/cli-maker/dist/index.js
+var require_dist = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.stripAnsiCodes = exports2.ParamType = exports2.CLI = undefined;
+  var command_1 = require_command();
+  Object.defineProperty(exports2, "CLI", { enumerable: true, get: function() {
+    return command_1.CLI;
+  } });
+  var interfaces_1 = require_interfaces();
+  Object.defineProperty(exports2, "ParamType", { enumerable: true, get: function() {
+    return interfaces_1.ParamType;
+  } });
+  var common_1 = require_common();
+  Object.defineProperty(exports2, "stripAnsiCodes", { enumerable: true, get: function() {
+    return common_1.stripAnsiCodes;
+  } });
+});
+
+// src/lib/clients/agents-generator/core/ApiError.ts
+var ApiError;
+var init_ApiError = __esm(() => {
+  ApiError = class ApiError extends Error {
+    url;
+    status;
+    statusText;
+    body;
+    request;
+    constructor(request, response, message) {
+      super(message);
+      this.name = "ApiError";
+      this.url = response.url;
+      this.status = response.status;
+      this.statusText = response.statusText;
+      this.body = response.body;
+      this.request = request;
+    }
+  };
+});
+
+// src/lib/clients/agents-generator/core/CancelablePromise.ts
+var CancelError, CancelablePromise;
+var init_CancelablePromise = __esm(() => {
+  CancelError = class CancelError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "CancelError";
+    }
+    get isCancelled() {
+      return true;
+    }
+  };
+  CancelablePromise = class CancelablePromise {
+    #isResolved;
+    #isRejected;
+    #isCancelled;
+    #cancelHandlers;
+    #promise;
+    #resolve;
+    #reject;
+    constructor(executor) {
+      this.#isResolved = false;
+      this.#isRejected = false;
+      this.#isCancelled = false;
+      this.#cancelHandlers = [];
+      this.#promise = new Promise((resolve, reject) => {
+        this.#resolve = resolve;
+        this.#reject = reject;
+        const onResolve = (value) => {
+          if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+            return;
+          }
+          this.#isResolved = true;
+          if (this.#resolve)
+            this.#resolve(value);
+        };
+        const onReject = (reason) => {
+          if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+            return;
+          }
+          this.#isRejected = true;
+          if (this.#reject)
+            this.#reject(reason);
+        };
+        const onCancel = (cancelHandler) => {
+          if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+            return;
+          }
+          this.#cancelHandlers.push(cancelHandler);
+        };
+        Object.defineProperty(onCancel, "isResolved", {
+          get: () => this.#isResolved
+        });
+        Object.defineProperty(onCancel, "isRejected", {
+          get: () => this.#isRejected
+        });
+        Object.defineProperty(onCancel, "isCancelled", {
+          get: () => this.#isCancelled
+        });
+        return executor(onResolve, onReject, onCancel);
+      });
+    }
+    get [Symbol.toStringTag]() {
+      return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+      return this.#promise.then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+      return this.#promise.catch(onRejected);
+    }
+    finally(onFinally) {
+      return this.#promise.finally(onFinally);
+    }
+    cancel() {
+      if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+        return;
+      }
+      this.#isCancelled = true;
+      if (this.#cancelHandlers.length) {
+        try {
+          for (const cancelHandler of this.#cancelHandlers) {
+            cancelHandler();
+          }
+        } catch (error) {
+          console.warn("Cancellation threw an error", error);
+          return;
+        }
+      }
+      this.#cancelHandlers.length = 0;
+      if (this.#reject)
+        this.#reject(new CancelError("Request aborted"));
+    }
+    get isCancelled() {
+      return this.#isCancelled;
+    }
+  };
+});
+
+// src/lib/clients/agents-generator/core/OpenAPI.ts
+var OpenAPI;
+var init_OpenAPI = __esm(() => {
+  OpenAPI = {
+    BASE: "",
+    VERSION: "main-3e9b5b5b62a0af3d34e07f2a82593d3a5b0543da",
+    WITH_CREDENTIALS: false,
+    CREDENTIALS: "include",
+    TOKEN: undefined,
+    USERNAME: undefined,
+    PASSWORD: undefined,
+    HEADERS: undefined,
+    ENCODE_PATH: undefined
+  };
+});
+
+// src/lib/clients/agents-generator/core/request.ts
+var isDefined = (value) => {
+  return value !== undefined && value !== null;
+}, isString = (value) => {
+  return typeof value === "string";
+}, isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+}, isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+}, isFormData = (value) => {
+  return value instanceof FormData;
+}, base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+}, getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process2 = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process2(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process2(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process2(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+}, getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+}, getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData;
+    const process2 = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process2(key, v));
+      } else {
+        process2(key, value);
+      }
+    });
+    return formData;
+  }
+  return;
+}, resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+}, getHeaders = async (config, options) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => ({
+    ...headers2,
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body !== undefined) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+}, getRequestBody = (options) => {
+  if (options.body !== undefined) {
+    if (options.mediaType?.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return;
+}, sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController;
+  const request = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request.credentials = config.CREDENTIALS;
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request);
+}, getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return;
+}, getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const jsonTypes = ["application/json", "application/problem+json"];
+        const isJSON = jsonTypes.some((type) => contentType.toLowerCase().startsWith(type));
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return;
+}, catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return;
+      }
+    })();
+    throw new ApiError(options, result, `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`);
+  }
+}, request = (config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+var init_request = __esm(() => {
+  init_ApiError();
+  init_CancelablePromise();
+});
+
+// src/lib/clients/agents-generator/services/AgentService.ts
+class AgentService {
+  static createAgentAgentsPost(requestBody, userId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents",
+      query: {
+        user_id: userId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentsAgentsGet(skip, limit = 100, userId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents",
+      query: {
+        skip,
+        limit,
+        user_id: userId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateAgentAgentsAgentIdPut(agentId, requestBody, userId) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentAgentsAgentIdGet(agentId, userId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteAgentAgentsAgentIdDelete(agentId, userId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static initializeAgentAgentsAgentIdInitializePost(agentId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents/{agent_id}/initialize",
+      path: {
+        agent_id: agentId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static queryAgentAgentsAgentIdQueryPost(agentId, requestBody, userId, conversationId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents/{agent_id}/query",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId,
+        conversation_id: conversationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static visualizeAgentAgentsAgentIdVisualizeGet(agentId, userId, format = "png") {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents/{agent_id}/visualize",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId,
+        format
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_AgentService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/ConversationsService.ts
+var init_ConversationsService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/McpServersService.ts
+var init_McpServersService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/RootService.ts
+class RootService {
+  static rootGet() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/"
+    });
+  }
+  static healthCheckHealthGet() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/health"
+    });
+  }
+}
+var init_RootService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/index.ts
+var init_agents_generator = __esm(() => {
+  init_ApiError();
+  init_CancelablePromise();
+  init_OpenAPI();
+  init_AgentService();
+  init_ConversationsService();
+  init_McpServersService();
+  init_RootService();
+});
+
+// src/commands/agentsCommand.ts
+var import_cli_maker, commandAgents, agentsCommand_default;
+var init_agentsCommand = __esm(() => {
+  import_cli_maker = __toESM(require_dist());
+  init_agents_generator();
+  commandAgents = {
+    name: "getAgents",
+    description: "Get the list of agents",
+    params: [{
+      name: "URL",
+      description: "The URL of the API",
+      required: true,
+      type: import_cli_maker.ParamType.Url
+    }],
+    action: async (args) => {
+      OpenAPI["BASE"] = args.URL;
+      const agents = await AgentService.getAgentsAgentsGet();
+      const hello = await RootService.healthCheckHealthGet();
+      console.log(hello);
+    }
+  };
+  agentsCommand_default = commandAgents;
+});
+
+// src/commands/rootCommand.ts
+var import_cli_maker2, rootCommand, rootCommand_default;
+var init_rootCommand = __esm(() => {
+  import_cli_maker2 = __toESM(require_dist());
+  init_agents_generator();
+  rootCommand = {
+    name: "version",
+    description: "Get the version of the API",
+    params: [{
+      name: "URL",
+      description: "The URL of the API",
+      required: false,
+      type: import_cli_maker2.ParamType.Url
+    }],
+    action: async (args) => {
+      OpenAPI["BASE"] = args.URL || "https://api.agentsgenerator.dev/";
+      console.log(OpenAPI);
+      const hello = await RootService.healthCheckHealthGet();
+      console.log(hello);
+    }
+  };
+  rootCommand_default = rootCommand;
+});
+
+// src/cli.ts
+var exports_cli = {};
+__export(exports_cli, {
+  cli: () => cli
+});
+var import_cli_maker3, cli;
+var init_cli = __esm(() => {
+  import_cli_maker3 = __toESM(require_dist());
+  init_agents_generator();
+  init_agentsCommand();
+  init_rootCommand();
+  cli = new import_cli_maker3.CLI("@ideascol/agents-generator-sdk", "agents-generator-sdk", {
+    interactive: true,
+    version: OpenAPI.VERSION
+  });
+  cli.command(rootCommand_default);
+  cli.command(agentsCommand_default);
+  cli.parse(process.argv);
+});
+
+// src/bin/cli.ts
+init_cli();