@cenk1cenk2/oclif-common 3.9.5 → 3.9.7

package/dist/hooks/not-found.hook.js

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -17,701 +15,19 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/hooks/not-found.hook.ts
 var not_found_hook_exports = {};
 __export(not_found_hook_exports, {
   notFoundHook: () => notFoundHook
 });
 module.exports = __toCommonJS(not_found_hook_exports);
-var import_core3 = require("@oclif/core");
-
-// src/utils/logger/listr-logger.ts
-var import_listr22 = require("listr2");
-
-// src/utils/logger/logger.ts
-var import_listr2 = require("listr2");
-var import_os2 = require("os");
-var import_winston = __toESM(require("winston"));
-
-// src/utils/logger/logger.constants.ts
-var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
-  LogLevels2["SILENT"] = "SILENT";
-  LogLevels2["DIRECT"] = "DIRECT";
-  LogLevels2["FATAL"] = "FATAL";
-  LogLevels2["ERROR"] = "ERROR";
-  LogLevels2["WARN"] = "WARN";
-  LogLevels2["INFO"] = "INFO";
-  LogLevels2["VERBOSE"] = "VERBOSE";
-  LogLevels2["DEBUG"] = "DEBUG";
-  LogLevels2["TRACE"] = "TRACE";
-  return LogLevels2;
-})(LogLevels || {});
-
-// src/lib/config/config.service.ts
-var import_object_path_immutable = __toESM(require("object-path-immutable"));
-var import_path2 = require("path");
-
-// src/interfaces/oclif.interface.ts
 var import_core = require("@oclif/core");
-
-// src/constants/global-flags.constants.ts
-var CLI_FLAGS = {
-  ["log-level"]: import_core.Flags.enum({
-    default: "INFO" /* INFO */,
-    env: "LOG_LEVEL",
-    description: "Set the log level of the application.",
-    options: [...Object.values(LogLevels), ...Object.values(LogLevels).map((level) => level.toLowerCase())],
-    helpGroup: "CLI" /* CLI */,
-    parse: async (input) => input?.toUpperCase()
-  }),
-  ci: import_core.Flags.boolean({
-    default: false,
-    env: "CI",
-    description: "Instruct whether this is running the CI/CD configuration.",
-    helpGroup: "CLI" /* CLI */
-  }),
-  json: import_core.Flags.boolean({
-    default: false,
-    env: "JSON",
-    description: "Put the CLI to respond in JSON.",
-    helpGroup: "CLI" /* CLI */
-  })
-};
-
-// src/lib/parser/env-parser.service.ts
-var import_os = require("os");
-var _EnvironmentVariableParser = class {
-  constructor() {
-    this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
-    if (_EnvironmentVariableParser.instance) {
-      return _EnvironmentVariableParser.instance;
-    }
-    _EnvironmentVariableParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
-  }
-  parse(data) {
-    try {
-      return data.toString().split(import_os.EOL).reduce((o, line) => {
-        const match = this.LINE.exec(line);
-        const key = match[1];
-        const value = match[2] ?? "";
-        return {
-          ...o,
-          [key]: value
-        };
-      }, {});
-    } catch (e) {
-      this.logger.trace("Error during parsing environment file: %s", e.message);
-      throw e;
-    }
-  }
-  stringify(data) {
-    return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(import_os.EOL) + import_os.EOL;
-  }
-};
-var EnvironmentVariableParser = _EnvironmentVariableParser;
-__name(EnvironmentVariableParser, "EnvironmentVariableParser");
-EnvironmentVariableParser.extensions = ["env"];
-
-// src/lib/parser/json-parser.service.ts
-var _JsonParser = class {
-  constructor() {
-    if (_JsonParser.instance) {
-      return _JsonParser.instance;
-    }
-    _JsonParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
-  }
-  parse(data) {
-    try {
-      return JSON.parse(data.toString());
-    } catch (e) {
-      this.logger.trace("Error during parsing JSON file: %s", e.message);
-      throw e;
-    }
-  }
-  stringify(data) {
-    return JSON.stringify(data, null, 2);
-  }
-};
-var JsonParser = _JsonParser;
-__name(JsonParser, "JsonParser");
-JsonParser.extensions = ["json"];
-
-// src/lib/parser/yaml-parser.service.ts
-var import_yaml = require("yaml");
-var _YamlParser = class {
-  constructor() {
-    if (_YamlParser.instance) {
-      return _YamlParser.instance;
-    }
-    _YamlParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
-  }
-  parse(data) {
-    try {
-      return (0, import_yaml.parse)(data.toString());
-    } catch (e) {
-      this.logger.trace("Error during parsing YAML file: %s", e.message);
-      throw e;
-    }
-  }
-  stringify(data) {
-    return (0, import_yaml.stringify)(data, { prettyErrors: true });
-  }
-};
-var YamlParser = _YamlParser;
-__name(YamlParser, "YamlParser");
-YamlParser.extensions = ["yaml", "yml"];
-
-// src/lib/fs/filesystem.service.ts
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_path = require("path");
-var FileSystemService = class {
-  constructor() {
-    if (FileSystemService.instance) {
-      return FileSystemService.instance;
-    } else {
-      FileSystemService.instance = this;
-      this.logger = new Logger(this.constructor.name);
-      this.logger.trace("Created a new instance.");
-    }
-  }
-  exists(path) {
-    return import_fs_extra.default.existsSync(path);
-  }
-  stats(path) {
-    return import_fs_extra.default.statSync(path, { throwIfNoEntry: true });
-  }
-  dirname(path) {
-    return (0, import_path.dirname)(path);
-  }
-  extname(path) {
-    return (0, import_path.extname)(path);
-  }
-  async read(file) {
-    try {
-      const raw = await import_fs_extra.default.readFile(file, "utf-8");
-      return raw;
-    } catch (e) {
-      throw new Error(`Error while reading file from "${file}": ${e.message}`);
-    }
-  }
-  readSync(file) {
-    try {
-      const raw = import_fs_extra.default.readFileSync(file, "utf-8");
-      return raw;
-    } catch (e) {
-      throw new Error(`Error while reading file from "${file}": ${e.message}`);
-    }
-  }
-  async write(file, data, options = {}) {
-    try {
-      await import_fs_extra.default.writeFile(file, data, { encoding: "utf-8", ...options });
-    } catch (e) {
-      throw new Error(`Error while writing file to "${file}": ${e.message}`);
-    }
-  }
-  writeSync(file, data, options = {}) {
-    try {
-      import_fs_extra.default.writeFileSync(file, data, { encoding: "utf-8", ...options });
-    } catch (e) {
-      throw new Error(`Error while writing file to "${file}": ${e.message}`);
-    }
-  }
-  async append(file, data, options) {
-    try {
-      await import_fs_extra.default.appendFile(file, data, options);
-    } catch (e) {
-      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
-    }
-  }
-  appendSync(file, data) {
-    try {
-      import_fs_extra.default.appendFileSync(file, data);
-    } catch (e) {
-      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
-    }
-  }
-  async remove(file, options) {
-    try {
-      await import_fs_extra.default.rm(file, options);
-    } catch (e) {
-      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
-    }
-  }
-  removeSync(file, options) {
-    try {
-      import_fs_extra.default.rmSync(file, options);
-    } catch (e) {
-      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
-    }
-  }
-  async emptyDir(directory) {
-    try {
-      await import_fs_extra.default.emptyDir(directory);
-    } catch (e) {
-      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
-    }
-  }
-  emptyDirSync(directory) {
-    try {
-      import_fs_extra.default.emptyDirSync(directory);
-    } catch (e) {
-      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
-    }
-  }
-  async removeDir(directory) {
-    try {
-      await import_fs_extra.default.rmdir(directory);
-    } catch (e) {
-      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
-    }
-  }
-  removeDirSync(directory) {
-    try {
-      import_fs_extra.default.rmdirSync(directory);
-    } catch (e) {
-      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
-    }
-  }
-  async mkdir(directory) {
-    try {
-      await import_fs_extra.default.mkdirp(directory);
-    } catch (e) {
-      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
-    }
-  }
-  mkdirSync(directory) {
-    try {
-      import_fs_extra.default.mkdirSync(directory);
-    } catch (e) {
-      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
-    }
-  }
-};
-__name(FileSystemService, "FileSystemService");
-
-// src/lib/parser/parser.service.ts
-var ParserService = class {
-  constructor(parsers) {
-    this.parsers = [YamlParser, JsonParser, EnvironmentVariableParser];
-    if (ParserService.instance) {
-      return ParserService.instance;
-    } else {
-      if (parsers) {
-        this.parsers = parsers;
-      }
-      this.logger = new Logger(this.constructor.name);
-      this.fs = new FileSystemService();
-      ParserService.instance = this;
-      this.logger.trace("Created a new instance.");
-    }
-  }
-  getParser(file) {
-    const ext = (file.includes(".") ? this.fs.extname(file) : file).replace(/^\./, "");
-    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext));
-    if (!Parser) {
-      throw new Error(`Parser for the extension is not configured: ${ext}`);
-    }
-    return new Parser();
-  }
-  setParsers(...parsers) {
-    this.parsers = parsers;
-    this.logger.trace(
-      "Set parsers: %s",
-      this.parsers.map((p) => p.name)
-    );
-  }
-  addParsers(...parsers) {
-    this.parsers.push(...parsers);
-    this.logger.trace(
-      "Added parser, current parsers: %s",
-      this.parsers.map((p) => p.name)
-    );
-  }
-  async read(file) {
-    return this.parse(file, await this.fs.read(file));
-  }
-  async write(file, data) {
-    return this.fs.write(file, await this.stringify(file, data));
-  }
-  parse(file, data) {
-    const parser = this.getParser(file);
-    this.logger.trace("Parsing file: %s -> %s", file, parser.constructor.name);
-    return parser.parse(data);
-  }
-  stringify(file, data) {
-    const parser = this.getParser(file);
-    this.logger.trace("Stringifying file: %s -> %s", file, parser.constructor.name);
-    return parser.stringify(data);
-  }
-};
-__name(ParserService, "ParserService");
-
-// src/utils/color.ts
-var colorette = __toESM(require("colorette"));
-var color = colorette.createColors({ useColor: true });
-
-// src/utils/environment.ts
-function isVerbose(logLevel) {
-  return logLevel === "VERBOSE" /* VERBOSE */;
-}
-__name(isVerbose, "isVerbose");
-function isDebug(logLevel) {
-  return ["DEBUG" /* DEBUG */, "TRACE" /* TRACE */].includes(logLevel);
-}
-__name(isDebug, "isDebug");
-function isSilent(logLevel) {
-  return logLevel === "SILENT" /* SILENT */;
-}
-__name(isSilent, "isSilent");
-
-// src/utils/merge.ts
-var import_deepmerge = __toESM(require("deepmerge"));
-function merge(strategy, ...source) {
-  return import_deepmerge.default.all(source, {
-    arrayMerge: strategy === "EXTEND" /* EXTEND */ ? (dest, src) => [...dest, ...src].filter(uniqueFilter) : (_, src) => src
-  });
-}
-__name(merge, "merge");
-function uniqueFilter(value, index, self) {
-  return self.indexOf(value) === index;
-}
-__name(uniqueFilter, "uniqueFilter");
-
-// src/utils/index.ts
-var import_core2 = require("@oclif/core");
-
-// src/lib/config/config.service.ts
-var ConfigService = class {
-  constructor(oclif, command, config) {
-    this.oclif = oclif;
-    this.command = command;
-    if (ConfigService.instance) {
-      if (Object.entries(config).some(([key, value]) => value !== ConfigService.instance[key])) {
-        ConfigService.instance.recalculate(config);
-      }
-      return ConfigService.instance;
-    }
-    this.root = this.oclif.root;
-    this.defaults = (0, import_path2.join)(this.oclif.root, "config" /* CONFIG_SERVICE_DEFAULTS_DIR */);
-    this.logger = new Logger(this.constructor.name, { level: config.logLevel });
-    this.parser = new ParserService();
-    this.recalculate(config);
-    ConfigService.instance = this;
-    this.logger.trace("Created a new instance.");
-  }
-  async read(path) {
-    const config = await this.parser.read(path);
-    this.logger.trace("Read config from: %s", path);
-    return config;
-  }
-  async extend(paths, strategy = "OVERWRITE" /* OVERWRITE */) {
-    this.logger.trace("Will generate config from: %o with %s", paths, strategy);
-    const configs = (await Promise.all(
-      paths.map(async (path) => {
-        try {
-          const config = typeof path === "string" ? await this.parser.read(path) : path;
-          this.logger.trace("Extending config from: %s", path);
-          return config;
-        } catch (e) {
-          this.logger.trace("Failed to extend config from: %s", e.message);
-        }
-      })
-    )).filter(Boolean);
-    return this.merge(configs, strategy);
-  }
-  merge(configs, strategy = "OVERWRITE" /* OVERWRITE */) {
-    if (configs.length === 0) {
-      throw new Error("Nothing to merge, configuration files are empty.");
-    }
-    return merge(strategy, ...configs);
-  }
-  async env(definition, config) {
-    const env = typeof definition === "string" ? await this.parser.read(definition) : definition;
-    this.logger.trace("Environment variable extensions read: %o", definition);
-    const iter = /* @__PURE__ */ __name(async (obj, parent) => {
-      const data = await Promise.all(
-        Object.entries(obj).map(async ([key, value]) => {
-          const location = [...parent ?? [], key];
-          if (typeof value === "string") {
-            return [{ key: location, env: value }];
-          } else if (typeof value === "object") {
-            let extensions;
-            if ("__element" /* ELEMENT */ in value) {
-              extensions = await iter(value["__element" /* ELEMENT */], [...location, "__element" /* ELEMENT */]);
-              this.logger.trace("Expanding location to elements: %s -> %s", location, extensions.map((extension) => extension.key.join(".")).join(", "));
-            }
-            if ("__name" /* NAME */ in value && "__format" /* PARSER */ in value) {
-              const variable = [
-                {
-                  key: location,
-                  env: value["__name" /* NAME */],
-                  parser: value["__format" /* PARSER */],
-                  extensions
-                }
-              ];
-              return variable;
-            } else {
-              return iter(value, location);
-            }
-          }
-        })
-      );
-      return data.flatMap((d) => d).filter(Boolean);
-    }, "iter");
-    const parsed = await iter(env);
-    const cb = /* @__PURE__ */ __name((config2, variable, data) => {
-      if (variable.parser) {
-        try {
-          data = this.parser.parse(variable.parser, data);
-        } catch (e) {
-          this.logger.trace("Can not parse environment environment variable for config: %s -> %s with %s", variable.key.join("."), variable.env, variable.parser);
-          throw e;
-        }
-      }
-      this.logger.trace("Overwriting config with environment variable: %s -> %s", variable.key.join("."), variable.env);
-      return import_object_path_immutable.default.set(config2, variable.key, data);
-    }, "cb");
-    parsed.forEach((variable) => {
-      let data;
-      data = process.env[variable.env];
-      if (data) {
-        config = cb(config, variable, data);
-      }
-      if (variable.extensions && variable.extensions.length > 0) {
-        const timeout = 6e4;
-        const startedAt = Date.now();
-        for (let i = 0; i < Infinity; i++) {
-          if (Date.now() - startedAt > timeout) {
-            throw new Error(`Timed-out in ${timeout}ms while looking for element environment variables.`);
-          }
-          const extensions = variable.extensions.map((extension) => {
-            const clone = JSON.parse(JSON.stringify(extension));
-            clone.env = clone.env.replace("${i}" /* ELEMENT_REPLACER */, i.toString());
-            clone.key[clone.key.findIndex((value) => value === "__element" /* ELEMENT */)] = i.toString();
-            data = process.env[clone.env];
-            if (!data) {
-              this.logger.trace("No extension for environment variable: %s -> %s", clone.key.join("."), clone.env);
-              return;
-            }
-            config = cb(config, clone, data);
-            return true;
-          }).filter(Boolean);
-          if (extensions.length === 0) {
-            this.logger.trace("No more extensions for environment variables: %s -> %d", variable.key.join("."), i);
-            break;
-          }
-        }
-      }
-    });
-    return config;
-  }
-  async write(path, data) {
-    return this.parser.write(path, data);
-  }
-  recalculate(config) {
-    this.ci = config.ci;
-    this.json = config.json;
-    this.logLevel = config.logLevel;
-    this.isVerbose = isVerbose(config.logLevel);
-    this.isDebug = isDebug(config.logLevel);
-    this.isSilent = isSilent(config.logLevel);
-  }
-};
-__name(ConfigService, "ConfigService");
-
-// src/lib/locker/locker.service.ts
-var import_object_path_immutable2 = __toESM(require("object-path-immutable"));
-
-// src/lib/validator/validator.service.ts
-var import_class_transformer = require("class-transformer");
-var import_class_validator = require("class-validator");
-
-// src/utils/logger/logger.ts
-var Logger = class {
-  constructor(context, options) {
-    this.context = context;
-    this.options = options;
-    const parsed = (process.env.LOG_LEVEL ?? options?.level ?? "INFO" /* INFO */).toUpperCase();
-    const level = Object.values(LogLevels).includes(parsed) ? parsed : "INFO" /* INFO */;
-    this.options = {
-      useIcons: true,
-      ...options,
-      level
-    };
-    if (Logger.instance) {
-      this.logger = Logger.instance;
-    } else if (context === ConfigService.name) {
-      this.logger = this.initiateLogger();
-      this.trace("Logger singleton initiated from context: %s", context);
-      Logger.instance = this.logger;
-    }
-  }
-  log(level, data, ...args) {
-    return this.parseMessage(level, data, args);
-  }
-  direct(data, ...args) {
-    return this.parseMessage("DIRECT" /* DIRECT */, data, args);
-  }
-  fatal(data, ...args) {
-    return this.parseMessage("FATAL" /* FATAL */, data, args);
-  }
-  error(data, ...args) {
-    return this.parseMessage("ERROR" /* ERROR */, data, args);
-  }
-  warn(data, ...args) {
-    return this.parseMessage("WARN" /* WARN */, data, args);
-  }
-  info(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args);
-  }
-  debug(data, ...args) {
-    return this.parseMessage("DEBUG" /* DEBUG */, data, args);
-  }
-  verbose(data, ...args) {
-    return this.parseMessage("VERBOSE" /* VERBOSE */, data, args);
-  }
-  trace(data, ...args) {
-    return this.parseMessage("TRACE" /* TRACE */, data, args);
-  }
-  run(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args, { status: "run" /* RUN */ });
-  }
-  end(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args, { status: "end" /* END */ });
-  }
-  stage(data, ...args) {
-    return this.parseMessage("TRACE" /* TRACE */, data, args, { status: "stage" /* STAGE */ });
-  }
-  initiateLogger() {
-    const logFormat = import_winston.format.printf(({ level, message, context, status }) => {
-      let multiLineMessage;
-      multiLineMessage = message.split(import_os2.EOL);
-      multiLineMessage = multiLineMessage.filter((msg) => msg.trim() !== "").filter(Boolean);
-      multiLineMessage = multiLineMessage.map((msg) => {
-        return this.logColoring({
-          level,
-          message: msg,
-          context,
-          status
-        });
-      });
-      return multiLineMessage.join(import_os2.EOL);
-    });
-    const logger = import_winston.default.createLogger({
-      level: this.options.level,
-      format: import_winston.format.combine(import_winston.format.splat(), import_winston.format.json({ space: 2 }), import_winston.format.prettyPrint(), logFormat),
-      levels: Object.values(LogLevels).reduce((o, level, i) => {
-        return {
-          ...o,
-          [level]: i
-        };
-      }, {}),
-      silent: this.options.level === "SILENT" /* SILENT */,
-      transports: [
-        new import_winston.transports.Console({
-          stderrLevels: ["FATAL" /* FATAL */, "ERROR" /* ERROR */]
-        })
-      ]
-    });
-    logger.log("TRACE" /* TRACE */, "Initiated new logger with level: %s", this.options.level, { context: this.constructor.name });
-    return logger;
-  }
-  parseMessage(level, data, args, format2) {
-    if (!this.logger && !Logger.instance) {
-      return;
-    } else if (Logger.instance) {
-      this.logger = Logger.instance;
-    }
-    this.logger.log(level, data.toString(), ...args ?? [], { context: this.context, ...format2 ?? {} });
-  }
-  logColoring({ level, message, context, status }) {
-    let icon;
-    let coloring = /* @__PURE__ */ __name((input) => {
-      return input;
-    }, "coloring");
-    let msgColoring = /* @__PURE__ */ __name((input) => {
-      return input;
-    }, "msgColoring");
-    switch (level) {
-      case "DIRECT" /* DIRECT */:
-        return message;
-      case "FATAL" /* FATAL */:
-        coloring = /* @__PURE__ */ __name((input) => color.red(input), "coloring");
-        if (this.options?.useIcons) {
-          icon = import_listr2.figures.checkboxOn;
-        }
-        break;
-      case "ERROR" /* ERROR */:
-        coloring = color.red;
-        if (this.options?.useIcons) {
-          icon = import_listr2.figures.cross;
-        }
-        break;
-      case "WARN" /* WARN */:
-        coloring = color.yellow;
-        if (this.options?.useIcons) {
-          icon = import_listr2.figures.warning;
-        }
-        break;
-      case "INFO" /* INFO */:
-        coloring = color.green;
-        if (this.options?.useIcons) {
-          icon = import_listr2.figures.pointerSmall;
-        }
-        break;
-      case "VERBOSE" /* VERBOSE */:
-        coloring = color.dim;
-        if (this.options?.useIcons) {
-          icon = "\u2607";
-        }
-        break;
-      case "DEBUG" /* DEBUG */:
-        coloring = color.cyan;
-        msgColoring = color.dim;
-        if (this.options?.useIcons) {
-          icon = "\uF188";
-        }
-        break;
-      case "TRACE" /* TRACE */:
-        coloring = color.magenta;
-        msgColoring = color.dim;
-        if (this.options?.useIcons) {
-          icon = "\u26B1";
-        }
-        break;
-    }
-    if (!icon) {
-      icon = `[${level.at(0).toUpperCase()}]`;
-    }
-    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
-  }
-};
-__name(Logger, "Logger");
-
-// src/utils/logger/pipe/pipe-process-to-listr.ts
-var import_through = __toESM(require("through"));
-
-// src/utils/logger/pipe/pipe-process-to-logger.ts
-var import_through2 = __toESM(require("through"));
-
-// src/hooks/not-found.hook.ts
-var notFoundHook = /* @__PURE__ */ __name(async (opts) => {
-  const logger = new Logger(opts.config.name);
+var import_logger = require("../utils/logger");
+const notFoundHook = /* @__PURE__ */ __name(async (opts) => {
+  const logger = new import_logger.Logger(opts.config.name);
   logger.fatal("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.", { custom: opts.config.name });
   logger.direct("");
-  const help = new import_core3.Help(opts.config);
+  const help = new import_core.Help(opts.config);
   await help.showHelp(["--all"]);
   process.exit(127);
 }, "notFoundHook");