@foxford/cli 1.0.0-beta-6f7848f0-20250318

package/fox.js

@@ -0,0 +1,1812 @@
+#!/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/logger/index.ts
+var import_logger, logger;
+var init_logger = __esm({
+  "src/logger/index.ts"() {
+    "use strict";
+    import_logger = require("@foxford/logger");
+    logger = import_logger.log.getLogger("cli");
+    logger.setLevel("info");
+  }
+});
+
+// src/program/abstract.action.ts
+var AbstractAction;
+var init_abstract_action = __esm({
+  "src/program/abstract.action.ts"() {
+    "use strict";
+    AbstractAction = class {
+      constructor(program) {
+        this.program = program;
+      }
+    };
+  }
+});
+
+// src/program/abstract.command.ts
+var AbstractCommand;
+var init_abstract_command = __esm({
+  "src/program/abstract.command.ts"() {
+    "use strict";
+    AbstractCommand = class {
+      constructor(action) {
+        this.action = action;
+      }
+    };
+  }
+});
+
+// src/lib/runners/runner.ts
+var init_runner = __esm({
+  "src/lib/runners/runner.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/runners/ffmpeg.runner.ts
+var import_node_path, import_chalk, import_fluent_ffmpeg, FFMpegRunner;
+var init_ffmpeg_runner = __esm({
+  "src/lib/runners/ffmpeg.runner.ts"() {
+    "use strict";
+    import_node_path = __toESM(require("path"));
+    import_chalk = __toESM(require("chalk"));
+    import_fluent_ffmpeg = __toESM(require("fluent-ffmpeg"));
+    FFMpegRunner = class {
+      constructor(options) {
+        this.options = options != null ? options : {};
+      }
+      run(payload) {
+        return __async(this, null, function* () {
+          return new Promise((resolve, reject) => {
+            var _a, _b;
+            (0, import_fluent_ffmpeg.default)(payload.resource).output((_a = payload.output) != null ? _a : import_node_path.default.basename(payload.resource)).outputOptions([
+              "-hide_banner",
+              "-movflags +faststart",
+              "-pix_fmt yuv420p",
+              "-c:v libx264",
+              "-preset:v veryslow",
+              "-profile:v high",
+              "-level 3.1",
+              "-tune:v ssim",
+              "-r 30",
+              "-g 180",
+              "-keyint_min 180",
+              "-sc_threshold 0",
+              "-max_muxing_queue_size 1024",
+              // '-vf scale=1920:-1',
+              "-f mp4",
+              ...(_b = payload.extraFlags) != null ? _b : []
+            ]).on("end", function() {
+              resolve(payload.resource);
+            }).on("error", function(err) {
+              console.log();
+              console.log(import_chalk.default.redBright("Cannot process video: " + err.message));
+              reject(err);
+            }).run();
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/lib/runners/shell.runner.ts
+var import_child_process, import_chalk2, ShellRunner;
+var init_shell_runner = __esm({
+  "src/lib/runners/shell.runner.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_chalk2 = __toESM(require("chalk"));
+    ShellRunner = class {
+      constructor(binary, options) {
+        this.binary = binary;
+        this.options = options != null ? options : { cwd: process.cwd() };
+      }
+      run(_0) {
+        return __async(this, arguments, function* (command, args = [], options = {}, collect = false) {
+          const spawnOptions = __spreadValues({
+            cwd: this.options.cwd,
+            stdio: collect ? "pipe" : "inherit",
+            shell: true
+          }, options);
+          return new Promise((resolve, reject) => {
+            const child = (0, import_child_process.spawn)(`${this.binary}`, [command, ...args], spawnOptions);
+            if (collect && child.stdout) {
+              child.stdout.on("data", (data) => resolve(data.toString().replace(/\r\n|\n/, "")));
+            }
+            child.on("close", (code) => {
+              if (code === 0) {
+                resolve(child.stdout);
+              } else {
+                console.error(import_chalk2.default.red(`
+ \u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C \u043A\u043E\u043C\u0430\u043D\u0434\u0443: ${this.binary} ${command} ${args} `));
+                reject(code);
+              }
+            });
+          });
+        });
+      }
+      runSync(command) {
+        const spawnOptions = {
+          cwd: this.options.cwd,
+          encoding: "utf-8"
+        };
+        return (0, import_child_process.execSync)(`${this.binary} ${command}`, spawnOptions);
+      }
+      /**
+       * @param command
+       * @returns The entire command that will be ran when calling `run(command)`.
+       */
+      rawFullCommand(command) {
+        const commandArgs = [command];
+        return `${this.binary} ${commandArgs.join(" ")}`;
+      }
+    };
+  }
+});
+
+// src/lib/runners/node.runner.ts
+var NodeRunner;
+var init_node_runner = __esm({
+  "src/lib/runners/node.runner.ts"() {
+    "use strict";
+    init_shell_runner();
+    NodeRunner = class extends ShellRunner {
+      constructor(options) {
+        super("node", options);
+      }
+    };
+  }
+});
+
+// src/lib/runners/npm.runner.ts
+var NpmRunner;
+var init_npm_runner = __esm({
+  "src/lib/runners/npm.runner.ts"() {
+    "use strict";
+    init_shell_runner();
+    NpmRunner = class extends ShellRunner {
+      constructor(options) {
+        super("npm", options);
+      }
+    };
+  }
+});
+
+// src/lib/runners/pnpm.runner.ts
+var PnpmRunner;
+var init_pnpm_runner = __esm({
+  "src/lib/runners/pnpm.runner.ts"() {
+    "use strict";
+    init_shell_runner();
+    PnpmRunner = class extends ShellRunner {
+      constructor(options) {
+        super("pnpm", options);
+      }
+    };
+  }
+});
+
+// src/helpers/env.ts
+function truthy(value) {
+  return !!value;
+}
+function loadEnv(pkgPath) {
+  const dotenvFiles = [
+    Boolean("production") && import_node_path2.default.join(pkgPath, `.env.${"production"}.local`),
+    Boolean("production") && import_node_path2.default.join(pkgPath, `.env.${"production"}`),
+    Boolean("production") === false && import_node_path2.default.join(pkgPath, `.env.development`),
+    import_node_path2.default.join(pkgPath, `.env.local`),
+    import_node_path2.default.join(pkgPath, ".env")
+  ].filter(truthy);
+  dotenvFiles.forEach((dotenvFile) => {
+    if (import_fs_extra.default.existsSync(dotenvFile)) {
+      import_dotenv_expand.default.expand(
+        import_dotenv.default.config({
+          path: dotenvFile
+        })
+      );
+    }
+  });
+  return dotenvFiles;
+}
+var import_node_path2, import_dotenv, import_dotenv_expand, import_fs_extra;
+var init_env = __esm({
+  "src/helpers/env.ts"() {
+    "use strict";
+    import_node_path2 = __toESM(require("path"));
+    import_dotenv = __toESM(require("dotenv"));
+    import_dotenv_expand = __toESM(require("dotenv-expand"));
+    import_fs_extra = __toESM(require("fs-extra"));
+  }
+});
+
+// src/helpers/logger.ts
+var label;
+var init_logger2 = __esm({
+  "src/helpers/logger.ts"() {
+    "use strict";
+    label = (chalk13, label2) => chalk13.black(` ${label2} `);
+  }
+});
+
+// src/lib/runners/script.runner.ts
+var import_chalk3, getLabel, getFailLabel, ScriptRunner;
+var init_script_runner = __esm({
+  "src/lib/runners/script.runner.ts"() {
+    "use strict";
+    import_chalk3 = __toESM(require("chalk"));
+    init_pnpm_runner();
+    init_env();
+    init_logger2();
+    getLabel = (pkgName) => {
+      return label(import_chalk3.default.bgGreen, pkgName) + import_chalk3.default.white(" ");
+    };
+    getFailLabel = (pkgName) => {
+      return label(import_chalk3.default.bgRed, pkgName) + import_chalk3.default.white(" ");
+    };
+    ScriptRunner = class {
+      constructor(options) {
+        this.options = options != null ? options : {};
+      }
+      run(_0, _1) {
+        return __async(this, arguments, function* (script, { pkg }) {
+          const label2 = getLabel(pkg.localName.toUpperCase());
+          const failLabel = getFailLabel(pkg.localName.toUpperCase());
+          console.log(label2 + import_chalk3.default.blue(`Start ${import_chalk3.default.white.underline(script)} process`));
+          if (this.options.verbose) {
+            console.log(label2 + import_chalk3.default.blue(`Print typescript config`));
+            console.log();
+          }
+          console.log(
+            label2 + import_chalk3.default.blue(`Env ${import_chalk3.default.magenta("process.env.NODE_ENV")} is ${import_chalk3.default.yellow("production")}`)
+          );
+          console.log(
+            label2 + import_chalk3.default.blue(`Env ${import_chalk3.default.magenta("process.env.NODE_OPTIONS")} is ${import_chalk3.default.yellow(process.env.NODE_OPTIONS)}`)
+          );
+          try {
+            console.log(label2 + import_chalk3.default.blue(`Load .env files`));
+            const envFiles = loadEnv(pkg.path);
+            console.log(JSON.stringify(envFiles, null, 2));
+          } catch (err) {
+            if (err instanceof Error) {
+              console.log(failLabel + import_chalk3.default.red(err.message));
+              process.exit(1);
+            }
+          }
+          const pnpmRunner = new PnpmRunner();
+          pnpmRunner.run("run", [`--filter ${pkg.localName}`, script], {
+            env: Object.assign(process.env, { FORCE_COLOR: "1" }),
+            cwd: pkg.path
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/lib/runners/tinypng.runner.ts
+var import_chalk4, import_tinify, TinyPngRunner;
+var init_tinypng_runner = __esm({
+  "src/lib/runners/tinypng.runner.ts"() {
+    "use strict";
+    import_chalk4 = __toESM(require("chalk"));
+    import_tinify = __toESM(require("tinify"));
+    TinyPngRunner = class {
+      constructor(options) {
+        this.options = options != null ? options : {};
+        if (!(options == null ? void 0 : options.token)) throw new Error("You must specify process.env.TINIFY_API_KEY env variable with tinify key");
+      }
+      run(payload) {
+        return __async(this, null, function* () {
+          var _a, _b, _c;
+          const source = import_tinify.default.fromFile(payload.resource);
+          import_tinify.default.key = (_b = (_a = this.options) == null ? void 0 : _a.token) != null ? _b : "";
+          try {
+            yield source.toFile((_c = payload.output) != null ? _c : payload.resource);
+          } catch (err) {
+            if (err instanceof Error) console.log(import_chalk4.default.redBright("Cannot compress resource with tinify: " + err.message));
+          }
+          return payload.resource;
+        });
+      }
+      runSync() {
+        throw new TypeError("this method not implemented");
+      }
+    };
+  }
+});
+
+// src/lib/runners/runner.factory.ts
+var RunnerMap, RunnerFactory;
+var init_runner_factory = __esm({
+  "src/lib/runners/runner.factory.ts"() {
+    "use strict";
+    init_ffmpeg_runner();
+    init_node_runner();
+    init_npm_runner();
+    init_pnpm_runner();
+    init_runner();
+    init_script_runner();
+    init_tinypng_runner();
+    RunnerMap = {
+      ["NPM" /* NPM */]: NpmRunner,
+      ["PNPM" /* PNPM */]: PnpmRunner,
+      ["NODE" /* NODE */]: NodeRunner,
+      ["PACKAGE_JSON_SCRIPT" /* PACKAGE_JSON_SCRIPT */]: ScriptRunner,
+      ["FFMPEG" /* FFMPEG */]: FFMpegRunner,
+      ["TINYPNG" /* TINYPNG */]: TinyPngRunner
+    };
+    RunnerFactory = class {
+      static create(runner, options) {
+        const RunnerClass = RunnerMap[runner];
+        if (!RunnerClass) {
+          throw new Error(`Unknown runner ${runner}`);
+        }
+        return new RunnerClass(options);
+      }
+    };
+  }
+});
+
+// src/lib/runners/index.ts
+var init_runners = __esm({
+  "src/lib/runners/index.ts"() {
+    "use strict";
+    init_runner();
+    init_runner_factory();
+  }
+});
+
+// src/program/program.ts
+var import_node_path3, import_commander, import_detect_package_manager, import_dotenv2, import_fs_extra2, import_zx, Program;
+var init_program = __esm({
+  "src/program/program.ts"() {
+    "use strict";
+    import_node_path3 = __toESM(require("path"));
+    import_commander = require("commander");
+    import_detect_package_manager = require("detect-package-manager");
+    import_dotenv2 = __toESM(require("dotenv"));
+    import_fs_extra2 = require("fs-extra");
+    import_zx = require("zx");
+    init_runners();
+    Program = class extends import_commander.Command {
+      constructor() {
+        super();
+        this.rootPath = process.cwd();
+        this.commandList = [];
+        import_zx.$.verbose = false;
+        const dotenvFiles = [
+          import_node_path3.default.resolve("./.env.local"),
+          import_node_path3.default.resolve("./.env"),
+          import_node_path3.default.resolve(__dirname, "../.env.local"),
+          import_node_path3.default.resolve(__dirname, "../.env")
+        ];
+        dotenvFiles.forEach((dotenvFile) => {
+          if ((0, import_fs_extra2.existsSync)(dotenvFile)) {
+            import_dotenv2.default.config({
+              path: dotenvFile
+            });
+          }
+        });
+        this.determineRootPath().then((path10) => this.rootPath = path10);
+      }
+      determineRootPath() {
+        return __async(this, null, function* () {
+          const packageManager = yield (0, import_detect_package_manager.detect)();
+          switch (packageManager) {
+            case "npm":
+              return import_node_path3.default.dirname(RunnerFactory.create("NPM" /* NPM */).runSync("root"));
+            case "pnpm":
+              return import_node_path3.default.dirname(RunnerFactory.create("PNPM" /* PNPM */).runSync("root"));
+            default:
+              return process.cwd();
+          }
+        });
+      }
+      defineCommand(command) {
+        this.commandList.push(command);
+      }
+      getCommands() {
+        return this.commandList;
+      }
+    };
+  }
+});
+
+// src/program/index.ts
+var init_program2 = __esm({
+  "src/program/index.ts"() {
+    "use strict";
+    init_abstract_action();
+    init_abstract_command();
+    init_program();
+  }
+});
+
+// src/lib/ui/banner.ts
+var BANNER;
+var init_banner = __esm({
+  "src/lib/ui/banner.ts"() {
+    "use strict";
+    BANNER = `
+\xB7\u2584\u2584\u2584      \u2590\u2584\u2022 \u2584 \xB7\u2584\u2584\u2584      \u2584\u2584\u2584  \xB7\u2584\u2584\u2584\u2584  
+\u2590\u2584\u2584\xB7\u25AA      \u2588\u258C\u2588\u258C\u25AA\u2590\u2584\u2584\xB7\u25AA     \u2580\u2584 \u2588\xB7\u2588\u2588\u25AA \u2588\u2588 
+\u2588\u2588\u25AA  \u2584\u2588\u2580\u2584  \xB7\u2588\u2588\xB7 \u2588\u2588\u25AA  \u2584\u2588\u2580\u2584 \u2590\u2580\u2580\u2584 \u2590\u2588\xB7 \u2590\u2588\u258C
+\u2588\u2588\u258C.\u2590\u2588\u258C.\u2590\u258C\u25AA\u2590\u2588\xB7\u2588\u258C\u2588\u2588\u258C.\u2590\u2588\u258C.\u2590\u258C\u2590\u2588\u2022\u2588\u258C\u2588\u2588. \u2588\u2588 
+\u2580\u2580\u2580  \u2580\u2588\u2584\u2580\u25AA\u2022\u2580\u2580 \u2580\u2580\u2580\u2580\u2580  \u2580\u2588\u2584\u2580\u25AA.\u2580  \u2580\u2580\u2580\u2580\u2580\u2580\u2022 
+`;
+  }
+});
+
+// src/lib/ui/prefixes.ts
+var import_chalk5, ERROR_PREFIX, INFO_PREFIX;
+var init_prefixes = __esm({
+  "src/lib/ui/prefixes.ts"() {
+    "use strict";
+    import_chalk5 = __toESM(require("chalk"));
+    ERROR_PREFIX = import_chalk5.default.bgRgb(210, 0, 75).bold.rgb(0, 0, 0)(" Error ");
+    INFO_PREFIX = import_chalk5.default.bgRgb(60, 190, 100).bold.rgb(0, 0, 0)(" Info ");
+  }
+});
+
+// src/lib/ui/index.ts
+var init_ui = __esm({
+  "src/lib/ui/index.ts"() {
+    "use strict";
+    init_banner();
+    init_prefixes();
+  }
+});
+
+// src/processes/codegen/index.ts
+var codegen_exports = {};
+__export(codegen_exports, {
+  default: () => codegen_default
+});
+var codegen_default;
+var init_codegen = __esm({
+  "src/processes/codegen/index.ts"() {
+    "use strict";
+    codegen_default = (_program) => {
+    };
+  }
+});
+
+// src/processes/codemod/action.ts
+var CodemodAction;
+var init_action = __esm({
+  "src/processes/codemod/action.ts"() {
+    "use strict";
+    init_runners();
+    init_program2();
+    CodemodAction = class extends AbstractAction {
+      handle(options) {
+        return __async(this, null, function* () {
+          const flags = [];
+          if (options.dry) flags.push("--dry");
+          if (options.verbose) flags.push("--verbose");
+          console.log("options", options);
+          console.log("flags", flags);
+          console.log("extra", options.extra);
+          const runner = RunnerFactory.create("NODE" /* NODE */, {
+            verbose: options.verbose
+          });
+          runner.run("", [], {
+            cwd: process.cwd()
+          });
+          return;
+        });
+      }
+    };
+  }
+});
+
+// src/lib/collection/collection.ts
+var init_collection = __esm({
+  "src/lib/collection/collection.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/collection/abstract.collection.ts
+var AbstractCollection;
+var init_abstract_collection = __esm({
+  "src/lib/collection/abstract.collection.ts"() {
+    "use strict";
+    AbstractCollection = class {
+      constructor(collection) {
+        this.collection = collection;
+      }
+      execute(_name, _inputs, _extraFlags, _cwd) {
+        return __async(this, null, function* () {
+          return;
+        });
+      }
+    };
+  }
+});
+
+// src/lib/utils/formatting.ts
+function normalizeToKebabOrSnakeCase(str) {
+  const STRING_DASHERIZE_REGEXP = /\s/g;
+  const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
+  return str.replace(STRING_DECAMELIZE_REGEXP, "$1-$2").toLowerCase().replace(STRING_DASHERIZE_REGEXP, "-");
+}
+var init_formatting = __esm({
+  "src/lib/utils/formatting.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/collection/fox-codemod.collection.ts
+var import_node_path4, import_chalk6, import_fs_extra3, FoxCodemodCollection;
+var init_fox_codemod_collection = __esm({
+  "src/lib/collection/fox-codemod.collection.ts"() {
+    "use strict";
+    import_node_path4 = __toESM(require("path"));
+    import_chalk6 = __toESM(require("chalk"));
+    import_fs_extra3 = __toESM(require("fs-extra"));
+    init_abstract_collection();
+    init_collection();
+    init_formatting();
+    FoxCodemodCollection = class extends AbstractCollection {
+      constructor() {
+        var _a;
+        super("@foxford/codemods" /* FOX_CODEMODS */);
+        this.codemods = [];
+        const pathCollection = require.resolve("@foxford/codemods" /* FOX_CODEMODS */);
+        const pkgJson = require(import_node_path4.default.join(import_node_path4.default.dirname(pathCollection), "package.json"));
+        if (!pkgJson.codemods) {
+          console.log(
+            import_chalk6.default.red('May be you must specify "codemods" section in your package.json with path to collection.json')
+          );
+          process.exit(1);
+        }
+        const collectionPath = import_node_path4.default.join(import_node_path4.default.dirname(pathCollection), (_a = pkgJson.codemods) != null ? _a : "");
+        if (!import_fs_extra3.default.existsSync(collectionPath)) {
+          console.log(
+            import_chalk6.default.red('Collection path specified in "codemods" section in your package.json is not valid: ', collectionPath)
+          );
+        }
+        try {
+          const collectionJson = require(collectionPath);
+          this.codemods = collectionJson.codemods.map((codemod) => __spreadProps(__spreadValues({}, codemod), {
+            name: normalizeToKebabOrSnakeCase(codemod.name)
+          }));
+        } catch (e) {
+          console.log(import_chalk6.default.red("Collection json is not valid"));
+        }
+      }
+      getItems() {
+        return this.codemods;
+      }
+    };
+  }
+});
+
+// src/lib/collection/collection.factory.ts
+var CollectionFactory;
+var init_collection_factory = __esm({
+  "src/lib/collection/collection.factory.ts"() {
+    "use strict";
+    init_collection();
+    init_fox_codemod_collection();
+    CollectionFactory = class {
+      static create(collection) {
+        if (collection === "@foxford/codemods" /* FOX_CODEMODS */) {
+          return new FoxCodemodCollection();
+        }
+        return new FoxCodemodCollection();
+      }
+    };
+  }
+});
+
+// src/lib/collection/index.ts
+var init_collection2 = __esm({
+  "src/lib/collection/index.ts"() {
+    "use strict";
+    init_collection_factory();
+    init_collection();
+    init_abstract_collection();
+  }
+});
+
+// src/processes/codemod/command.ts
+var import_chalk7, import_cli_table3, import_commander2, CodemodCommand;
+var init_command = __esm({
+  "src/processes/codemod/command.ts"() {
+    "use strict";
+    import_chalk7 = __toESM(require("chalk"));
+    import_cli_table3 = __toESM(require("cli-table3"));
+    import_commander2 = require("commander");
+    init_collection2();
+    init_program2();
+    CodemodCommand = class extends AbstractCommand {
+      constructor() {
+        super(...arguments);
+        this.id = "codemod";
+        this.items = [];
+      }
+      buildRunCommand() {
+        const verbose = new import_commander2.Option("--verbose", "\u0412\u044B\u0432\u043E\u0434 \u0434\u0430\u043D\u043D\u044B\u0445");
+        const dry = new import_commander2.Option("--dry", "\u041F\u0440\u043E\u0433\u043E\u043D \u0431\u0435\u0437 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439");
+        const run = new import_commander2.Command("run");
+        run.description("\u0417\u0430\u043F\u0443\u0441\u0438\u0442\u044C \u043A\u043E\u0434\u043C\u043E\u0434 \u0441 \u0438\u043C\u0435\u043D\u0435\u043C <name>").argument("<name>", "\u0418\u043C\u044F \u043A\u043E\u0434\u043C\u043E\u0434\u0430 (codemod --list)").argument("<input...>", "Glob \u043F\u0430\u0442\u0442\u0435\u0440\u043D \u0444\u0430\u0439\u043B\u043E\u0432 \u0434\u043B\u044F \u043A\u043E\u0442\u043E\u0440\u044B\u0445 \u0431\u0443\u0434\u0435\u0442 \u043F\u0440\u0438\u043C\u0435\u043D\u0438\u043C \u043A\u043E\u0434\u043C\u043E\u0434").addOption(verbose).addOption(dry).allowUnknownOption(true).showHelpAfterError().action((name, input, options, command) => __async(this, null, function* () {
+          var _a, _b;
+          if (!this.items.filter((item) => item.name === name)) {
+            console.error("Name not found");
+            return;
+          }
+          const unknownOptions = (_b = (_a = command.parseOptions(command.args)) == null ? void 0 : _a.unknown) != null ? _b : [];
+          const paths = input.filter((item) => !unknownOptions.includes(item));
+          if (unknownOptions.length) {
+            options.extra = unknownOptions;
+          }
+          options.paths = paths;
+          yield this.action.handle(options);
+        }));
+        return run;
+      }
+      buildListCommand() {
+        const run = new import_commander2.Command("list");
+        run.description("\u0412\u044B\u0432\u0435\u0441\u0442\u0438 \u043F\u043E\u043B\u043D\u044B\u0439 \u0441\u043F\u0438\u0441\u043E\u043A \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B\u0445 \u043A\u043E\u0434\u043C\u043E\u0434\u043E\u0432").showHelpAfterError().action(() => __async(this, null, function* () {
+          const list = yield this.getCollectionItems();
+          console.log(
+            `\u0414\u043E\u0441\u0442\u0443\u043F\u043D\u044B\u0435 \u043A\u043E\u0434\u043C\u043E\u0434\u044B \u0438\u0437 ${import_chalk7.default.bold(this.getCollection())}:
+` + this.buildSchematicsListAsTable(list)
+          );
+        }));
+        return run;
+      }
+      getCollectionItems() {
+        return __async(this, null, function* () {
+          const list = yield this.getItems(this.getCollection());
+          this.items = list;
+          return list;
+        });
+      }
+      load(program) {
+        return __async(this, null, function* () {
+          const codemod = new import_commander2.Command("codemod");
+          codemod.addHelpText(
+            "before",
+            `
+---------------------------------------
+${import_chalk7.default.greenBright(
+              "\u{1F6E0}  Codemod manager"
+            )}
+---------------------------------------
+`
+          ).usage("<command>").helpOption(false).description(yield this.buildDescription()).summary("\u0423\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u043A\u043E\u0434\u043C\u043E\u0434\u0430\u043C\u0438").addCommand(this.buildRunCommand()).addCommand(this.buildListCommand()).action((options) => __async(this, null, function* () {
+            if (!options || Object.keys(options).length === 0) {
+              codemod.outputHelp();
+              return;
+            }
+            yield this.action.handle(options);
+          }));
+          program.addCommand(codemod);
+        });
+      }
+      buildSchematicsListAsTable(items) {
+        const leftMargin = "    ";
+        const tableConfig = {
+          head: ["name", "description"],
+          chars: {
+            left: leftMargin.concat("\u2502"),
+            "top-left": leftMargin.concat("\u250C"),
+            "bottom-left": leftMargin.concat("\u2514"),
+            mid: "",
+            "left-mid": "",
+            "mid-mid": "",
+            "right-mid": ""
+          }
+        };
+        const table = new import_cli_table3.default(tableConfig);
+        for (const item of items) {
+          table.push([import_chalk7.default.green(item.name), item.description]);
+        }
+        return table.toString();
+      }
+      getCollection() {
+        return "@foxford/codemods" /* FOX_CODEMODS */;
+      }
+      getItems(collection) {
+        return __async(this, null, function* () {
+          const abstractCollection = CollectionFactory.create(collection);
+          this.items = yield abstractCollection.getItems();
+          return this.items;
+        });
+      }
+      buildDescription() {
+        return __async(this, null, function* () {
+          const list = yield this.getCollectionItems();
+          const shortList = list.slice(0, 20);
+          return `\u0414\u043E\u0441\u0442\u0443\u043F\u043D\u044B\u0435 \u043A\u043E\u0434\u043C\u043E\u0434\u044B \u0438\u0437 ${import_chalk7.default.bold(this.getCollection())}:
+` + this.buildSchematicsListAsTable(shortList) + import_chalk7.default.yellowBright(`
+
+\u0427\u0442\u043E\u0431\u044B \u0443\u0432\u0438\u0434\u0435\u0442\u044C \u043F\u043E\u043B\u043D\u044B\u0439 \u0441\u043F\u0438\u0441\u043E\u043A \u043A\u043E\u0434\u043C\u043E\u0434\u043E\u0432 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 \u043A\u043E\u043C\u0430\u043D\u0434\u0443 `) + import_chalk7.default.greenBright(`codemod list`);
+        });
+      }
+    };
+  }
+});
+
+// src/processes/codemod/index.ts
+var codemod_exports = {};
+__export(codemod_exports, {
+  default: () => codemod_default
+});
+var codemod_default;
+var init_codemod = __esm({
+  "src/processes/codemod/index.ts"() {
+    "use strict";
+    init_action();
+    init_command();
+    codemod_default = (program) => {
+      program.defineCommand(new CodemodCommand(new CodemodAction(program)));
+    };
+  }
+});
+
+// src/processes/deploy/providers/abstract.provider.ts
+var import_zx2, DeployProvider;
+var init_abstract_provider = __esm({
+  "src/processes/deploy/providers/abstract.provider.ts"() {
+    "use strict";
+    import_zx2 = require("zx");
+    init_logger();
+    DeployProvider = class {
+      constructor(providerName) {
+        this.providerName = providerName;
+        this.cwd = process.cwd();
+        this.logger = logger.getLogger(providerName);
+        this.buildDir = "./build";
+        this.packageJson = this.readPackageJson();
+      }
+      /**
+       * Читает и парсит файл package.json из текущей рабочей директории.
+       *
+       * Эта функция пытается найти и прочитать файл package.json в текущей
+       * рабочей директории. Если файл найден, он читается синхронно и парсится как JSON.
+       *
+       * @throws {Error} Выбрасывает ошибку, если файл package.json не найден в текущей директории
+       *                 или если возникла ошибка при чтении/парсинге файла.
+       * @returns {FoxfordTools.PackageJson} Распарсенное содержимое файла package.json.
+       */
+      readPackageJson(rootPath = this.cwd) {
+        const packageJsonPath = import_zx2.path.resolve(rootPath, "package.json");
+        console.log(packageJsonPath);
+        if (!import_zx2.fs.existsSync(packageJsonPath)) {
+          throw new Error("package.json \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u0432 \u0442\u0435\u043A\u0443\u0449\u0435\u0439 \u0434\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u0438");
+        }
+        try {
+          const packageJsonContent = import_zx2.fs.readFileSync(packageJsonPath, "utf-8");
+          return JSON.parse(packageJsonContent);
+        } catch (error) {
+          throw new Error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0447\u0442\u0435\u043D\u0438\u0438 \u0438\u043B\u0438 \u043F\u0430\u0440\u0441\u0438\u043D\u0433\u0435 package.json: ${error.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/processes/deploy/providers/cdn.ts
+var import_zx3, CdnDeploy;
+var init_cdn = __esm({
+  "src/processes/deploy/providers/cdn.ts"() {
+    "use strict";
+    import_zx3 = require("zx");
+    init_abstract_provider();
+    init_logger();
+    CdnDeploy = class extends DeployProvider {
+      constructor() {
+        super("cdn");
+      }
+      /**
+       * Определяет цель развертывания на основе текущей ветки Git.
+       *
+       * @returns {'latest' | 'beta'} 'latest' для ветки master, 'beta' для всех остальных.
+       */
+      getTarget() {
+        const { GITHUB_REF_NAME } = process.env;
+        if (GITHUB_REF_NAME === "master") return "latest";
+        return "beta";
+      }
+      /**
+       * Формирует удаленный путь для версии пакета.
+       *
+       * @param {string} bucket - Имя бакета.
+       * @param {string} packageName - Имя пакета.
+       * @returns {string} Полный путь для версии пакета.
+       */
+      getRemoteDirByVersion(bucket, packageName) {
+        return `${bucket}/libs/${packageName}/${this.packageJson.version}/`;
+      }
+      /**
+       * Формирует удаленный путь для цели развертывания.
+       *
+       * @param {string} bucket - Имя бакета.
+       * @param {string} packageName - Имя пакета.
+       * @param {string} target - Цель развертывания ('latest' или 'beta').
+       * @returns {string} Полный путь для цели развертывания.
+       */
+      getRemoteDirByTarget(bucket, packageName, target) {
+        return `${bucket}/libs/${packageName}/${target}/`;
+      }
+      /**
+       * Выполняет процесс развертывания на CDN.
+       *
+       * Этот метод копирует файлы из локальной директории в удаленные директории CDN,
+       * используя rclone. Он обрабатывает как версионные, так и целевые пути.
+       *
+       * @param {DeployCdnOptions} params - Параметры развертывания.
+       * @param {string} [params.localDir] - Локальная директория для копирования (по умолчанию this.buildDir).
+       * @param {string} [params.bucket] - Имя бакета CDN (по умолчанию из env или 'dist.ngcdn.ru').
+       * @param {string} [params.packageName] - Имя пакета (по умолчанию из package.json).
+       * @param {'latest' | 'beta'} [params.target] - Цель развертывания (по умолчанию определяется автоматически).
+       * @param {boolean} [params.dry] - Если true, выполняет пробный запуск без фактической загрузки.
+       *
+       * @throws Завершает процесс, если локальная директория не существует.
+       */
+      deploy(params) {
+        return __async(this, null, function* () {
+          var _a, _b, _c, _d, _e;
+          const { OS_USERNAME, OS_PASSWORD } = process.env;
+          if (!OS_USERNAME || !OS_PASSWORD) {
+            this.logger.warn("\u041D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D\u044B \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0435 \u043E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u044F OS_USERNAME \u0438\u043B\u0438 OS_PASSWORD");
+          }
+          const localDir = import_zx3.path.join(process.cwd(), (_a = params.localDir) != null ? _a : this.buildDir);
+          this.packageJson = this.readPackageJson(localDir);
+          const bucket = (_c = (_b = params.bucket) != null ? _b : process.env.BUCKET) != null ? _c : "dist.ngcdn.ru";
+          const remoteDirs = [];
+          const packageName = (_d = params.packageName) != null ? _d : this.packageJson.name;
+          const target = (_e = params.target) != null ? _e : this.getTarget();
+          remoteDirs.push(this.getRemoteDirByVersion(bucket, packageName));
+          remoteDirs.push(this.getRemoteDirByTarget(bucket, packageName, target));
+          if (!import_zx3.fs.existsSync(localDir)) {
+            logger.error(`\u0414\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u044F "${localDir}" \u043D\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442`);
+            process.exit(1);
+          }
+          yield Promise.allSettled(
+            remoteDirs.map((remoteDir) => __async(this, null, function* () {
+              const rclone = `rclone copy ${localDir} myremote:${remoteDir} --progress --error-on-no-transfer`;
+              logger.log(`\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u043F\u0430\u043A\u0435\u0442\u0430 \u0432 ${remoteDir} \u0441 \u043A\u043E\u043C\u0430\u043D\u0434\u043E\u0439:
+	`, rclone);
+              yield import_zx3.$`rclone copy ${localDir} myremote:${remoteDir} --progress --error-on-no-transfer ${params.dry ? "--dry-run" : ""}`;
+            }))
+          );
+        });
+      }
+    };
+  }
+});
+
+// src/processes/deploy/providers/npm.ts
+function sleep(ms) {
+  if (false) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var import_zx4, NpmDeploy;
+var init_npm = __esm({
+  "src/processes/deploy/providers/npm.ts"() {
+    "use strict";
+    import_zx4 = require("zx");
+    init_abstract_provider();
+    init_logger();
+    NpmDeploy = class extends DeployProvider {
+      constructor() {
+        super("npm");
+        this.versionLists = [];
+        this.dry = "";
+      }
+      /**
+       * Возвращает сообщение об устаревании с текущим SHA коммита.
+       *
+       * @returns Промис, который разрешается строкой сообщения об устаревании.
+       */
+      getDeprecationMessage() {
+        return __async(this, null, function* () {
+          const commitSha = (yield import_zx4.$`git rev-parse --short HEAD`).toString().trim();
+          return `deprecated by ${commitSha}`;
+        });
+      }
+      /**
+       * Создает или обновляет файл .npmrc с токеном аутентификации для реестра npm.
+       *
+       * Этот метод добавляет конфигурацию аутентификации в файл .npmrc,
+       * обеспечивая безопасный доступ к реестру npm для публикации пакетов.
+       * Он использует переменную окружения NPM_TOKEN для аутентификации.
+       *
+       * @returns Промис, который разрешается, когда файл .npmrc успешно обновлен.
+       * @throws Выбрасывает ошибку, если операция с файлом не удалась или если NPM_TOKEN не установлен.
+       */
+      touchNpmrc() {
+        return __async(this, null, function* () {
+          yield import_zx4.$`echo "//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}" >> .npmrc`;
+        });
+      }
+      /**
+       * Генерирует строку версии пакета на основе цели и SHA коммита.
+       *
+       * @param target - Цель развертывания. Может быть 'beta' или 'latest'.
+       *                 Определяет, возвращать ли бета-версию или текущую версию пакета.
+       * @param sha - Короткий SHA коммита, используемый в строке бета-версии.
+       * @returns Строка, представляющая версию пакета.
+       *          Для цели 'latest' возвращает текущую версию пакета.
+       *          Для цели 'beta' возвращает строку версии в формате:
+       *          "<текущая_версия>-beta-<sha>-<текущая_дата>"
+       */
+      getBetaPackageVersion(sha) {
+        const now = /* @__PURE__ */ new Date();
+        const year = now.getFullYear();
+        const month = String(now.getMonth() + 1).padStart(2, "0");
+        const day = String(now.getDate()).padStart(2, "0");
+        const date = `${year}${month}${day}`;
+        return `${this.packageJson.version}-beta-${sha}-${date}`;
+      }
+      /**
+       * Фильтрует устаревшие версии из заданного списка версий пакета.
+       *
+       * Этот метод проверяет каждую версию в реестре npm, чтобы определить, является ли она устаревшей.
+       * Он использует команду `npm view` для получения статуса устаревания каждой версии.
+       *
+       * @param versions - Массив строк версий для проверки на устаревание.
+       * @returns Промис, который разрешается в массив строк версий, которые не являются устаревшими.
+       */
+      getNotDeprecatedVersions(versions) {
+        return __async(this, null, function* () {
+          const notDeprecatedVersions = [];
+          for (const ver of versions) {
+            const cmd = ["npm", "view", `${this.packageJson.name}@${ver}`, "deprecated"];
+            const result = yield import_zx4.$`${cmd}`;
+            if (!result.toString().trim().includes("deprecated by")) {
+              notDeprecatedVersions.push(ver);
+            }
+          }
+          return notDeprecatedVersions;
+        });
+      }
+      /**
+       * Получает список всех версий текущего пакета из реестра npm.
+       *
+       * Этот метод выполняет команду npm для получения всех версий пакета,
+       * указанного в файле package.json. Затем он парсит JSON-ответ
+       * и сохраняет результат в свойстве `versionLists` класса.
+       *
+       * @returns Промис, который разрешается в массив строк, где каждая строка
+       *          представляет версию пакета. Если парсинг не удался, возвращает
+       *          пустой массив.
+       *
+       * @throws Записывает ошибку в консоль, если парсинг JSON не удался, но не
+       *         выбрасывает исключение.
+       */
+      getVersionsList() {
+        return __async(this, null, function* () {
+          logger.info("Getting versions list...");
+          const outputProcess = yield import_zx4.$`npm view ${this.packageJson.name} versions --json`;
+          const versionsListPo = outputProcess.toString();
+          logger.info("Versions list recieved", versionsListPo);
+          try {
+            const parsed = JSON.parse(versionsListPo);
+            if (Array.isArray(parsed)) {
+              return parsed;
+            } else {
+              return [parsed];
+            }
+          } catch (e) {
+            logger.error("Error parsing versions list");
+            return [];
+          }
+        });
+      }
+      /**
+       * Получает список бэта версий на текущую версию из списка всех версий.
+       *
+       * @param currentVersion - Строка текущей версии для сравнения.
+       * @returns Массив строк похожих версий.
+       */
+      getBetaVersions(currentVersion) {
+        return this.versionLists.filter((ver) => {
+          var _a;
+          if (!ver.includes("beta")) return false;
+          if (ver === currentVersion) return false;
+          const semverFromVersion = currentVersion.match(/^[0-9]{1,9}.[0-9]{1,9}.[0-9]{1,9}/gi);
+          if (!semverFromVersion) return false;
+          const matchedVersion = (_a = semverFromVersion[0]) != null ? _a : null;
+          if (!matchedVersion) return false;
+          return ver.includes(matchedVersion);
+        });
+      }
+      /**
+       * Помечает предыдущие похожие версии пакета как устаревшие.
+       *
+       * Этот метод находит похожие версии на текущую версию, фильтрует уже устаревшие версии,
+       * а затем помечает оставшиеся версии как устаревшие, используя команду npm deprecate.
+       *
+       * @param currentVersion - Текущая версия пакета для сравнения при поиске похожих версий.
+       * @returns Промис, который разрешается, когда все похожие, не устаревшие версии были помечены как устаревшие или была попытка их пометить.
+       */
+      deprecatePrevBetaVersions(currentVersion) {
+        return __async(this, null, function* () {
+          logger.info("Set previous beta versions as deprecated");
+          this.versionLists = yield this.getVersionsList();
+          const betaVersions = this.getBetaVersions(currentVersion);
+          logger.info("Founded beta versions:", betaVersions);
+          const notDeprecatedVersions = yield this.getNotDeprecatedVersions(betaVersions);
+          logger.info("Not deprecated versions:", notDeprecatedVersions);
+          const deprecationMessage = yield this.getDeprecationMessage();
+          for (const ver of notDeprecatedVersions) {
+            yield sleep(500);
+            try {
+              if (!this.dry) {
+                const cmd = ["npm", "deprecate", `${this.packageJson.name}@${ver}`, deprecationMessage];
+                logger.info("Deprecate version:", cmd);
+                yield import_zx4.$`${cmd}`;
+              }
+            } catch (error) {
+              logger.error(error);
+              continue;
+            }
+          }
+        });
+      }
+      /**
+       * Удаляет бета-версии пакета, которые похожи на текущую версию.
+       *
+       * Этот метод получает все версии пакета, находит похожие версии на текущую,
+       * и удаляет те, которые являются бета-версиями. Он использует команду npm unpublish с флагом --force.
+       *
+       * @param currentVersion - Текущая версия пакета для сравнения при поиске похожих версий.
+       * @returns Промис, который разрешается, когда все бета-версии были удалены или была попытка их удалить.
+       * @throws Записывает ошибки в консоль, если удаление не удалось для какой-либо версии, но продолжает со следующей версией.
+       */
+      unpublishBetaVersions(currentVersion) {
+        return __async(this, null, function* () {
+          logger.info("Unpublish beta versions");
+          this.versionLists = yield this.getVersionsList();
+          logger.info("Version list: ", this.versionLists);
+          const betaVersions = this.getBetaVersions(currentVersion);
+          logger.info("List for unpublish & deprecating: ", betaVersions);
+          const deprecationMessage = yield this.getDeprecationMessage();
+          for (const ver of betaVersions) {
+            if (!ver.includes("beta")) continue;
+            try {
+              const deprecate = ["npm", "deprecate", `${this.packageJson.name}@${ver}`, deprecationMessage];
+              logger.info("Deprecate version:", deprecate);
+              yield import_zx4.$`${deprecate}`;
+              const unpublish = ["npm", "unpublish", `${this.packageJson.name}@${ver}`, "--force", this.dry];
+              logger.info("Unpublish version:", unpublish);
+              yield import_zx4.$`${unpublish}`;
+            } catch (error) {
+              logger.error(error);
+              continue;
+            }
+            yield sleep(500);
+          }
+        });
+      }
+      /**
+       * Разворачивает пакет в реестре npm.
+       *
+       * Этот метод обрабатывает весь процесс развертывания, включая управление версиями,
+       * обновление package.json, публикацию npm и пост-публикационные действия, такие как пометка
+       * предыдущих версий как устаревших или удаление бета-версий.
+       *
+       * @param params - Параметры развертывания.
+       * @param params.dry - Если true, выполняет пробный запуск без фактической публикации.
+       * @param params.target - Цель развертывания, либо 'beta', либо 'latest'. По умолчанию 'beta'.
+       *
+       * @throws Завершает процесс, если директория сборки не найдена.
+       * @returns Промис, который разрешается, когда процесс развертывания завершен.
+       */
+      deploy(params) {
+        return __async(this, null, function* () {
+          var _a, _b;
+          logger.info("Start deploy process to npm", params);
+          const localDir = import_zx4.path.join(process.cwd(), (_a = params.localDir) != null ? _a : this.buildDir);
+          if (!import_zx4.fs.existsSync(localDir)) {
+            logger.error(`\u0414\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u044F "${localDir}" \u043D\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442`);
+            process.exit(1);
+          }
+          this.packageJson = this.readPackageJson(localDir);
+          if (params.dry === true) this.dry = "--dry-run";
+          logger.info("Change directory to", localDir);
+          (0, import_zx4.cd)(localDir);
+          logger.info("Get commit sha");
+          const commitSha = (yield import_zx4.$`git rev-parse --short HEAD`).toString().replace("\n", "");
+          logger.info("Commit sha:", commitSha);
+          const target = (_b = params.target) != null ? _b : "beta";
+          logger.info("Target is:", target);
+          yield this.touchNpmrc();
+          logger.info("Touch .npmrc");
+          if (target === "beta") {
+            this.packageJson.version = this.packageJson.version.includes("beta") ? this.packageJson.version : this.getBetaPackageVersion(commitSha);
+          }
+          this.packageJson.sha = commitSha;
+          logger.info("Target version is:", this.packageJson.version);
+          if (this.packageJson.scripts && this.packageJson.scripts.postinstall) {
+            this.packageJson.scripts = {
+              postinstall: this.packageJson.scripts.postinstall
+            };
+          } else {
+            this.packageJson.scripts = {};
+          }
+          if (this.packageJson.devDependencies) {
+            delete this.packageJson.devDependencies;
+          }
+          logger.info("Resulted package.json", this.packageJson);
+          yield import_zx4.fs.writeJson("package.json", this.packageJson, {
+            spaces: 2
+          });
+          const cmd = ["npm", "publish", "--access=public", `--tag=${target}`, this.dry];
+          logger.info("Publish with args:", cmd);
+          yield import_zx4.$`${cmd}`;
+          if (target === "beta") {
+            yield this.deprecatePrevBetaVersions(this.packageJson.version);
+          } else {
+            yield this.unpublishBetaVersions(this.packageJson.version);
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/processes/deploy/action.ts
+var DeployAction;
+var init_action2 = __esm({
+  "src/processes/deploy/action.ts"() {
+    "use strict";
+    init_program2();
+    init_cdn();
+    init_npm();
+    DeployAction = class extends AbstractAction {
+      handle(params) {
+        return __async(this, null, function* () {
+          let provider;
+          switch (params.provider) {
+            case "npm":
+              provider = new NpmDeploy();
+              break;
+            case "cdn":
+              provider = new CdnDeploy();
+              break;
+            default:
+              throw new Error(`Unsupported deploy provider: ${params.provider}`);
+          }
+          yield provider.deploy(params);
+        });
+      }
+    };
+  }
+});
+
+// src/processes/deploy/command.ts
+var import_commander3, DeployCommand;
+var init_command2 = __esm({
+  "src/processes/deploy/command.ts"() {
+    "use strict";
+    import_commander3 = require("commander");
+    init_program2();
+    DeployCommand = class extends AbstractCommand {
+      constructor() {
+        super(...arguments);
+        this.id = "deploy";
+      }
+      load(program) {
+        return __async(this, null, function* () {
+          const deployCommand = new import_commander3.Command("deploy").description("\u0417\u0430\u0434\u0435\u043F\u043B\u043E\u0438\u0442\u044C \u043F\u0430\u043A\u0435\u0442");
+          const targetOption = new import_commander3.Option("--target <target>", "\u0420\u0435\u043B\u0438\u0437 beta \u0438\u043B\u0438 latest").choices(["beta", "latest"]).default("beta");
+          const localDirOption = new import_commander3.Option("--localDir <path>", "\u0418\u0437 \u043A\u0430\u043A\u043E\u0439 \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u043E\u0439 \u0434\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u0438 \u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044C \u0441\u043E\u0434\u0435\u0440\u0436\u0438\u043C\u043E\u0435");
+          const dryOption = new import_commander3.Option("--dry", "\u0417\u0430\u043F\u0443\u0441\u043A \u0431\u0435\u0437 \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044F \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438").default(false);
+          const cdnCommand = new import_commander3.Command("cdn").description("\u0414\u0435\u043F\u043B\u043E\u0439 \u043F\u0430\u043A\u0435\u0442\u0430 \u0432 cdn").option("--bucket <name>", "\u0412 \u043A\u0430\u043A\u043E\u0439 \u0431\u0430\u043A\u0435\u0442 \u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044C \u043F\u0430\u043A\u0435\u0442").option("--packageName <name>", "\u0418\u043C\u044F \u043F\u0430\u043A\u0435\u0442\u0430 \u0432\u043C\u0435\u0441\u0442\u043E packageJson.name").action((params) => __async(this, null, function* () {
+            yield this.action.handle(__spreadProps(__spreadValues({}, params), { provider: "cdn" }));
+          }));
+          cdnCommand.addOption(targetOption);
+          cdnCommand.addOption(localDirOption);
+          cdnCommand.addOption(dryOption);
+          const npmCommand = new import_commander3.Command("npm").description("\u0414\u0435\u043F\u043B\u043E\u0439 \u043F\u0430\u043A\u0435\u0442\u0430 \u0432 npm").action((params) => __async(this, null, function* () {
+            yield this.action.handle(__spreadProps(__spreadValues({}, params), { provider: "npm" }));
+          }));
+          npmCommand.addOption(targetOption);
+          npmCommand.addOption(localDirOption);
+          npmCommand.addOption(dryOption);
+          deployCommand.addCommand(cdnCommand);
+          deployCommand.addCommand(npmCommand);
+          program.addCommand(deployCommand);
+        });
+      }
+    };
+  }
+});
+
+// src/processes/deploy/index.ts
+var deploy_exports = {};
+__export(deploy_exports, {
+  default: () => deploy_default
+});
+var deploy_default;
+var init_deploy = __esm({
+  "src/processes/deploy/index.ts"() {
+    "use strict";
+    init_action2();
+    init_command2();
+    deploy_default = (program) => {
+      program.defineCommand(new DeployCommand(new DeployAction(program)));
+    };
+  }
+});
+
+// src/processes/info/action.ts
+var import_os, import_chalk8, import_filesize, import_os_name, import_systeminformation, import_zx5, InfoAction;
+var init_action3 = __esm({
+  "src/processes/info/action.ts"() {
+    "use strict";
+    import_os = require("os");
+    import_chalk8 = __toESM(require("chalk"));
+    import_filesize = require("filesize");
+    import_os_name = __toESM(require("os-name"));
+    import_systeminformation = __toESM(require("systeminformation"));
+    import_zx5 = require("zx");
+    init_ui();
+    init_program2();
+    InfoAction = class extends AbstractAction {
+      handle() {
+        return __async(this, null, function* () {
+          this.displayBanner();
+          yield this.displaySystemInformation();
+        });
+      }
+      displayBanner() {
+        console.info(import_chalk8.default.red(BANNER));
+      }
+      displaySystemInformation() {
+        return __async(this, null, function* () {
+          console.info(import_chalk8.default.green("[System Information]"));
+          console.info("OS Version     :", import_chalk8.default.blue((0, import_os_name.default)((0, import_os.platform)(), (0, import_os.release)())));
+          console.info("NodeJS Version :", import_chalk8.default.blue(process.version));
+          const where = yield import_zx5.$`which node`;
+          console.info("NodeJS path :", where.toString());
+          console.info("NODE_OPTIONS :", import_chalk8.default.blue(process.env.NODE_OPTIONS));
+          if (where.toString().includes("nvm")) {
+            console.info("NVM_DIR :", import_chalk8.default.blue(process.env.NVM_DIR));
+          }
+          console.log();
+          const cpu = yield import_systeminformation.default.cpu();
+          const mem = yield import_systeminformation.default.mem();
+          console.info("CPU Family:", import_chalk8.default.blue(`${cpu.vendor} ${cpu.brand}`));
+          console.info("CPU Ph Cores:", import_chalk8.default.blue(cpu.cores));
+          console.info("CPU Speed:", import_chalk8.default.blue(`${cpu.speed}GHz`));
+          console.info("Memory:", import_chalk8.default.blue(`${(0, import_filesize.filesize)(mem.total)}`));
+          console.info("Memory Free:", import_chalk8.default.blue(`${(0, import_filesize.filesize)(mem.free)}`));
+          console.info("Memory Used:", import_chalk8.default.blue(`${(0, import_filesize.filesize)(mem.used)}`));
+          console.info("Memory Available:", import_chalk8.default.blue(`${(0, import_filesize.filesize)(mem.available)}`));
+        });
+      }
+      rightPad(name, length) {
+        while (name.length < length) {
+          name = name.concat(" ");
+        }
+        return name;
+      }
+    };
+  }
+});
+
+// src/processes/info/command.ts
+var InfoCommand;
+var init_command3 = __esm({
+  "src/processes/info/command.ts"() {
+    "use strict";
+    init_program2();
+    InfoCommand = class extends AbstractCommand {
+      constructor() {
+        super(...arguments);
+        this.id = "info";
+      }
+      load(program) {
+        return __async(this, null, function* () {
+          program.command("info").alias("i").description("\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u044C \u0438\u043D\u0444\u043E").action(() => __async(this, null, function* () {
+            yield this.action.handle();
+          }));
+        });
+      }
+    };
+  }
+});
+
+// src/processes/info/index.ts
+var info_exports = {};
+__export(info_exports, {
+  default: () => info_default
+});
+var info_default;
+var init_info = __esm({
+  "src/processes/info/index.ts"() {
+    "use strict";
+    init_action3();
+    init_command3();
+    info_default = (program) => {
+      program.defineCommand(new InfoCommand(new InfoAction(program)));
+    };
+  }
+});
+
+// src/processes/optimize/action.ts
+var import_fs, import_node_path5, import_chalk9, import_cli_progress, import_cli_table32, import_filesize2, import_glob, import_inquirer, OptimizeAction;
+var init_action4 = __esm({
+  "src/processes/optimize/action.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    import_node_path5 = __toESM(require("path"));
+    import_chalk9 = __toESM(require("chalk"));
+    import_cli_progress = __toESM(require("cli-progress"));
+    import_cli_table32 = __toESM(require("cli-table3"));
+    import_filesize2 = require("filesize");
+    import_glob = require("glob");
+    import_inquirer = __toESM(require("inquirer"));
+    init_runners();
+    init_program2();
+    OptimizeAction = class extends AbstractAction {
+      constructor() {
+        super(...arguments);
+        this.buildStatusTable = (results) => {
+          const success = results.filter((item) => item.status === true);
+          const failed = results.filter((item) => item.status === false);
+          const leftMargin = "";
+          const table = new import_cli_table32.default({
+            head: ["\u041E\u0431\u0440\u0430\u0431\u043E\u0442\u0430\u043D\u043E", "\u041D\u0435 \u043E\u0431\u0440\u0430\u0431\u043E\u0442\u0430\u043D\u043E", "\u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0435 \u0440\u0430\u0437\u043C\u0435\u0440\u0430"],
+            chars: {
+              left: leftMargin.concat("\u2502"),
+              "top-left": leftMargin.concat("\u250C"),
+              "bottom-left": leftMargin.concat("\u2514"),
+              mid: "",
+              "left-mid": "",
+              "mid-mid": "",
+              "right-mid": ""
+            }
+          });
+          const sumFilesize = results.reduce((acc, task) => {
+            if (task.__originalStat && task.__optimizedStat) {
+              acc += task.__originalStat.size - task.__optimizedStat.size;
+            }
+            return acc;
+          }, 0);
+          const sumPrefix = sumFilesize >= 0 ? "-" : "+";
+          table.push([
+            import_chalk9.default.greenBright(success.length),
+            import_chalk9.default.redBright(failed.length),
+            sumFilesize >= 0 ? import_chalk9.default.greenBright(`${sumPrefix}${(0, import_filesize2.filesize)(sumFilesize)}`) : import_chalk9.default.redBright(`${sumPrefix}${(0, import_filesize2.filesize)(Math.abs(sumFilesize))}`)
+          ]);
+          return table.toString();
+        };
+      }
+      handle(_0) {
+        return __async(this, arguments, function* (options, extraFlags = []) {
+          const resources = yield (0, import_glob.glob)(import_node_path5.default.join(process.cwd(), options.filePath), { ignore: "node_modules/**" });
+          console.log(import_chalk9.default.white(`\u041D\u0430\u0439\u0434\u0435\u043D\u043E ${import_chalk9.default.green(resources.length)} \u0440\u0435\u0441\u0443\u0440\u0441\u043E\u0432 \u0434\u043B\u044F \u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0430\u0446\u0438\u0438`));
+          console.log(
+            import_chalk9.default.yellowBright(`\u0415\u0441\u043B\u0438 \u0432\u044B \u0445\u043E\u0442\u0438\u0442\u0435 \u0443\u0432\u0438\u0434\u0435\u0442\u044C \u0441\u043F\u0438\u0441\u043E\u043A \u0440\u0435\u0441\u0443\u0440\u0441\u043E\u0432, \u0432\u043E\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435\u0441\u044C \u043E\u043F\u0446\u0438\u0435\u0439 ${import_chalk9.default.green("--list")}`)
+          );
+          if (options.list) console.log(resources);
+          const answers = yield import_inquirer.default.prompt([
+            {
+              type: "list",
+              message: "\u041F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442\u044C?",
+              choices: [
+                { name: "Yes", value: 1 },
+                { name: "No", value: 0 }
+              ],
+              default: 0,
+              name: "continue"
+            }
+          ]);
+          if (!answers.continue) return;
+          console.log();
+          const bar = new import_cli_progress.default.SingleBar({ fps: 25 }, import_cli_progress.default.Presets.shades_classic);
+          bar.start(resources.length, 0);
+          const ft = yield import("file-type");
+          const promises = resources.map((resource) => __async(this, null, function* () {
+            var _a, _b;
+            const fileType = yield ft.fileTypeFromFile(resource);
+            if (!fileType)
+              return {
+                __originalPath: resource,
+                __optimizedPath: resource,
+                status: false
+              };
+            const { mime } = fileType;
+            let runner;
+            const outputPath = options.replace ? resource : import_node_path5.default.join(import_node_path5.default.dirname(resource), `${(_a = options.prefix) != null ? _a : ""}${import_node_path5.default.basename(resource)}`);
+            switch (mime) {
+              case "image/png":
+              case "image/jpeg":
+                runner = RunnerFactory.create("TINYPNG" /* TINYPNG */, {
+                  token: (_b = process.env.TINIFY_API_KEY) != null ? _b : "",
+                  verbose: true
+                });
+                break;
+              case "video/mp4":
+                runner = RunnerFactory.create("FFMPEG" /* FFMPEG */, {
+                  verbose: true
+                });
+                break;
+              default:
+                console.log(import_chalk9.default.yellowBright(`Unsupported mime type for ${import_chalk9.default.white(resource)}`));
+            }
+            if (!runner) {
+              return {
+                __originalPath: resource,
+                __optimizedPath: resource,
+                status: false
+              };
+            }
+            try {
+              const beforeStat = import_fs.default.statSync(resource);
+              yield runner.run({
+                resource,
+                output: outputPath,
+                extraFlags
+              });
+              const afterStat = import_fs.default.statSync(outputPath);
+              return {
+                __originalPath: resource,
+                __originalStat: beforeStat,
+                __optimizedPath: resource,
+                __optimizedStat: afterStat,
+                status: true
+              };
+            } catch (err) {
+              return {
+                __originalPath: resource,
+                __optimizedPath: resource,
+                status: false,
+                err
+              };
+            } finally {
+              bar.increment();
+            }
+          }));
+          yield Promise.all(promises).then((result) => {
+            bar.stop();
+            this.printResult(result);
+          });
+        });
+      }
+      printResult(result) {
+        const statusTable = this.buildStatusTable(result);
+        console.log(statusTable);
+        this.showUncompletedFiles(result);
+      }
+      showUncompletedFiles(results) {
+        const failed = results.filter((item) => item.status === false);
+        if (failed.length > 0) {
+          console.log(import_chalk9.default.redBright("\u0421\u043F\u0438\u0441\u043E\u043A \u043D\u0435\u043E\u0431\u0440\u0430\u0431\u043E\u0442\u0430\u043D\u043D\u044B\u0445 \u0444\u0430\u0439\u043B\u043E\u0432"));
+          console.log(failed.map((item) => item.__originalPath));
+        }
+      }
+    };
+  }
+});
+
+// src/processes/optimize/command.ts
+var import_chalk10, OptimizeCommand;
+var init_command4 = __esm({
+  "src/processes/optimize/command.ts"() {
+    "use strict";
+    import_chalk10 = __toESM(require("chalk"));
+    init_program2();
+    OptimizeCommand = class extends AbstractCommand {
+      constructor() {
+        super(...arguments);
+        this.id = "optimize";
+      }
+      load(program) {
+        return __async(this, null, function* () {
+          program.command("optimize [path] [extraFlags...]").alias("opt").option("-l, --list", "\u0412\u044B\u0432\u0435\u0441\u0442\u0438 \u0441\u043F\u0438\u0441\u043E\u043A \u0444\u0430\u0439\u043B\u043E\u0432 \u0434\u043B\u044F \u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0430\u0446\u0438\u0438", false).option("-r, --replace", "\u0417\u0430\u043C\u0435\u043D\u0438\u0442\u044C \u0438\u0441\u0445\u043E\u0434\u043D\u044B\u0439 \u0444\u0430\u0439\u043B", false).option("-p, --prefix", "\u041F\u0440\u0435\u0444\u0438\u043A\u0441 \u0432 \u0438\u043C\u0435\u043D\u0438 \u043E\u043F\u0442\u0438\u043C\u0430\u0439\u0437\u043D\u0443\u0442\u043E\u0433\u043E \u0444\u0430\u0439\u043B\u0430", "__").description("\u041E\u043F\u0442\u0438\u043C\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0440\u0435\u0441\u0443\u0440\u0441(jpg,png,mp4)").action((path10, extraFlags, option) => __async(this, null, function* () {
+            if (!path10) {
+              console.log(import_chalk10.default.yellow("\u0423\u043A\u0430\u0436\u0438\u0442\u0435 \u043F\u0443\u0442\u044C \u0434\u043E \u0440\u0435\u0441\u0443\u0440\u0441\u0430(\u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F glob)"));
+              process.exit(1);
+            }
+            yield this.action.handle(
+              {
+                filePath: path10,
+                list: option.list,
+                replace: option.replace,
+                prefix: option.prefix
+              },
+              extraFlags
+            );
+          }));
+        });
+      }
+    };
+  }
+});
+
+// src/processes/optimize/index.ts
+var optimize_exports = {};
+__export(optimize_exports, {
+  default: () => optimize_default
+});
+var optimize_default;
+var init_optimize = __esm({
+  "src/processes/optimize/index.ts"() {
+    "use strict";
+    init_action4();
+    init_command4();
+    optimize_default = (program) => {
+      program.defineCommand(new OptimizeCommand(new OptimizeAction(program)));
+    };
+  }
+});
+
+// src/bin/fox.ts
+var import_chalk12 = __toESM(require("chalk"));
+
+// package.json
+var package_default = {
+  name: "@foxford/cli",
+  version: "1.0.0",
+  description: "Foxford Cli",
+  keywords: [
+    "foxford",
+    "cli",
+    "tool"
+  ],
+  homepage: "https://github.com/foxford/stoege",
+  bugs: "https://github.com/foxford/stoege/issues",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/foxford/stoege.git"
+  },
+  license: "MIT",
+  author: "Foxford Co",
+  maintainers: [
+    {
+      name: "Roman Olin",
+      email: "r.v.olin@foxford.ru",
+      team: "@frontend/core"
+    }
+  ],
+  main: "./README.mdx",
+  exports: {
+    "./README.mdx": "./README.mdx"
+  },
+  bin: {
+    "fox-dev": "./scripts/dev.js",
+    fox: "./scripts/prod.js"
+  },
+  scripts: {
+    "============================ BUILD =============================": "",
+    build: "tsup",
+    prebuild: 'pnpm -w run build:workspace-deps "$PWD"',
+    "============================ DEPLOY =============================": "",
+    deploy: "fox deploy npm",
+    "============================ LINT =============================": "",
+    "lint:type-check": "tsc --noEmit --pretty",
+    "lint:eslint": "eslint --cache --cache-strategy content --max-warnings=0 ./",
+    "============================ TEST =============================": "",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  dependencies: {
+    "@foxford/logger": "workspace:*",
+    "@tsconfig/node16": "16.1.3",
+    "@types/cli-progress": "3.11.5",
+    "@types/fluent-ffmpeg": "2.1.24",
+    chalk: "4.1.0",
+    "cli-progress": "3.12.0",
+    "cli-table3": "0.6.5",
+    commander: "13.1.0",
+    "detect-package-manager": "3.0.2",
+    dotenv: "16.4.5",
+    "dotenv-expand": "11.0.6",
+    "file-type": "19.0.0",
+    filesize: "10.1.2",
+    "fluent-ffmpeg": "2.1.2",
+    "fs-extra": "11.2.0",
+    glob: "10.4.2",
+    inquirer: "12.4.3",
+    "os-name": "4.0.1",
+    systeminformation: "5.25.11",
+    tinify: "1.7.1",
+    tsx: "4.15.7",
+    typescript: "5.6.3",
+    yaml: "2.4.5",
+    zx: "8.1.3"
+  },
+  devDependencies: {
+    "@foxford/eslint-config": "workspace:*",
+    "@foxford/typescript-config": "workspace:*",
+    tsup: "8.4.0"
+  }
+};
+
+// src/bin/fox.ts
+init_logger();
+init_program2();
+
+// src/program/loader.ts
+var import_node_path6 = __toESM(require("path"));
+var import_chalk11 = __toESM(require("chalk"));
+var import_fs_extra4 = __toESM(require("fs-extra"));
+init_ui();
+init_logger();
+var log2 = logger.getLogger("command-loader");
+var _CommandLoader = class _CommandLoader {
+  static load(program) {
+    return __async(this, null, function* () {
+      if (true) {
+        yield this.loadProductionProcesses(program);
+      } else {
+        yield this.loadDevelopmentProcesses(program);
+      }
+      yield Promise.all(program.getCommands().map((command) => __async(this, null, function* () {
+        return yield command.load(program);
+      })));
+      this.handleInvalidCommand(program);
+    });
+  }
+  static loadProductionProcesses(program) {
+    return __async(this, null, function* () {
+      try {
+        for (const [processName, moduleLoader] of Object.entries({
+          codegen: () => Promise.resolve().then(() => (init_codegen(), codegen_exports)),
+          codemod: () => Promise.resolve().then(() => (init_codemod(), codemod_exports)),
+          deploy: () => Promise.resolve().then(() => (init_deploy(), deploy_exports)),
+          info: () => Promise.resolve().then(() => (init_info(), info_exports)),
+          optimize: () => Promise.resolve().then(() => (init_optimize(), optimize_exports))
+        })) {
+          try {
+            log2.debug(`\u0417\u0430\u0433\u0440\u0443\u0436\u0430\u0435\u043C \u043C\u043E\u0434\u0443\u043B\u044C: ${import_chalk11.default.cyan(processName)}`);
+            const module2 = yield moduleLoader();
+            module2.default(program);
+          } catch (err) {
+            log2.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0437\u0430\u0433\u0440\u0443\u0437\u043A\u0435 \u043C\u043E\u0434\u0443\u043B\u044F "${processName}":`, err);
+          }
+        }
+      } catch (err) {
+        log2.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0437\u0430\u0433\u0440\u0443\u0437\u043A\u0435 \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u043E\u0432:", err);
+      }
+    });
+  }
+  static loadDevelopmentProcesses(program) {
+    return __async(this, null, function* () {
+      try {
+        if (!(yield import_fs_extra4.default.pathExists(_CommandLoader.PROCESSES_DIR))) {
+          log2.error(`\u0414\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u044F \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u043E\u0432 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430: ${_CommandLoader.PROCESSES_DIR}`);
+          return;
+        }
+        const processes = yield this.getProcesses(_CommandLoader.PROCESSES_DIR);
+        for (const processName of processes) {
+          try {
+            log2.debug(`\u0417\u0430\u0433\u0440\u0443\u0436\u0430\u0435\u043C \u043C\u043E\u0434\u0443\u043B\u044C: ${import_chalk11.default.cyan(processName)}`);
+            const modulePath = import_node_path6.default.join(_CommandLoader.PROCESSES_DIR, processName);
+            const module2 = require(modulePath);
+            module2.default(program);
+          } catch (err) {
+            log2.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0437\u0430\u0433\u0440\u0443\u0437\u043A\u0435 \u043C\u043E\u0434\u0443\u043B\u044F "${processName}":`, err);
+          }
+        }
+      } catch (err) {
+        log2.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0447\u0442\u0435\u043D\u0438\u0438 \u0434\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u0438 \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u043E\u0432:", err);
+      }
+    });
+  }
+  static getProcesses(processesPath) {
+    return __async(this, null, function* () {
+      const files = yield import_fs_extra4.default.readdir(processesPath);
+      return files.filter((file) => {
+        const filePath = import_node_path6.default.join(processesPath, file, "index.ts");
+        const stat = import_fs_extra4.default.statSync(filePath);
+        return stat.isFile();
+      }).map((file) => import_node_path6.default.parse(file).name);
+    });
+  }
+  static handleInvalidCommand(program) {
+    program.on("command:*", () => {
+      console.error(`
+${ERROR_PREFIX} \u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u043A\u043E\u043C\u0430\u043D\u0434\u0430: ${import_chalk11.default.red("%s")}`, program.args.join(" "));
+      console.log(`\u0421\u043C\u043E\u0442\u0440\u0438 ${import_chalk11.default.red("--help")} \u0434\u043B\u044F \u0432\u044B\u0432\u043E\u0434\u0430 \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E\u0433\u043E \u0441\u043F\u0438\u0441\u043A\u0430 \u043A\u043E\u043C\u0430\u043D\u0434.
+`);
+      process.exit(1);
+    });
+  }
+};
+_CommandLoader.PROCESSES_DIR = import_node_path6.default.resolve(__dirname, "..", "processes");
+var CommandLoader = _CommandLoader;
+
+// src/bin/fox.ts
+var PROGRAM_NAME = "fox";
+var welcomeText = `${import_chalk12.default.green(`\u041F\u0440\u0438\u0432\u0435\u0442\u270C\uFE0F , Foxford \u0440\u0430\u0437\u0440\u0430\u0431\u043E\u0442\u0447\u0438\u043A\u{1F913}`)}
+${import_chalk12.default.magenta(`\u042D\u0442\u0430 \u0448\u0442\u0443\u043A\u0430 \u043F\u0440\u0438\u0437\u0432\u0430\u043D\u0430 \u043F\u043E\u043C\u043E\u0447\u044C \u0442\u0435\u0431\u0435 \u0432 \u043A\u043E\u0434\u043E\u0433\u0435\u043D\u0435\u0440\u0430\u0446\u0438\u0438 \u0438 \u0432 \u0447\u0435\u043C-\u043D\u0438\u0431\u0443\u0434\u044C \u0435\u0449\u0451\u{1F37F}`)}
+${import_chalk12.default.yellowBright("\u0427\u0430\u0439 \u043D\u0430\u043B\u0438\u0432\u0430\u0439 \u0441\u0435\u0431\u0435 \u0441\u0430\u043C \u{1F36E}\u{1F36A}")}
+`;
+var bootstrap = () => __async(exports, null, function* () {
+  logger.debug("Start program");
+  const program = new Program();
+  program.version(package_default.version, "-v, --version", "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u044C \u0442\u0435\u043A\u0443\u0449\u0443\u044E \u0432\u0435\u0440\u0441\u0438\u044E \u0442\u0443\u043B\u0437\u044B").name(PROGRAM_NAME).description(welcomeText).usage("<command> [options]").helpOption(false).addHelpCommand(false);
+  logger.debug("Load processes");
+  yield CommandLoader.load(program);
+  logger.debug("Loading complete");
+  logger.debug("Parse process.argv", process.argv);
+  yield program.parseAsync(process.argv);
+  if (!process.argv.slice(2).length) {
+    program.outputHelp();
+  }
+});
+bootstrap();
+//# sourceMappingURL=fox.js.map