@cenk1cenk2/oclif-common 3.7.1 → 3.8.0

package/dist/index.js

@@ -31,6 +31,7 @@ __export(src_exports, {
   Command: () => Command,
   ConfigCommand: () => ConfigCommand,
   ConfigService: () => ConfigService,
+  EnvironmentVariableParser: () => EnvironmentVariableParser,
   FileConstants: () => FileConstants,
   FileSystemService: () => FileSystemService,
   Flags: () => import_core.Flags,
@@ -59,6 +60,7 @@ __export(src_exports, {
   setCtxDefaults: () => setCtxDefaults,
   setup: () => setup,
   storeHook: () => storeHook,
+  uniqueFilter: () => uniqueFilter,
   updateNotifierHook: () => updateNotifierHook
 });
 module.exports = __toCommonJS(src_exports);
@@ -89,7 +91,7 @@ var import_listr22 = require("listr2");
 
 // src/utils/logger/logger.ts
 var import_listr2 = require("listr2");
-var import_os = require("os");
+var import_os2 = require("os");
 var import_winston = __toESM(require("winston"));
 
 // src/utils/logger/logger.constants.ts
@@ -114,372 +116,131 @@ var LogFieldStatus = /* @__PURE__ */ ((LogFieldStatus2) => {
   return LogFieldStatus2;
 })(LogFieldStatus || {});
 
-// src/utils/color.ts
-var colorette = __toESM(require("colorette"));
-var color = colorette.createColors({ useColor: true });
+// src/lib/config/config.service.ts
+var import_object_path_immutable = __toESM(require("object-path-immutable"));
+var import_path2 = require("path");
 
-// 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 {
-      this.logger = this.initiateLogger();
-      Logger.instance = this.logger;
+// 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.");
   }
-  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_os.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_os.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) => {
+  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,
-          [level]: i
+          [key]: value
         };
-      }, {}),
-      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;
+      }, {});
+    } catch (e) {
+      this.logger.trace("Error during parsing environment file: %s", e.message);
+      throw e;
+    }
   }
-  parseMessage(level, data, args, format2) {
-    this.logger.log(level, data.toString(), ...args ?? [], { context: this.context, ...format2 ?? {} });
+  stringify(data) {
+    return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(import_os.EOL) + import_os.EOL;
   }
-  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;
+};
+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;
     }
-    if (!icon) {
-      icon = `[${level.at(0).toUpperCase()}]`;
+    _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;
     }
-    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
+  }
+  stringify(data) {
+    return JSON.stringify(data, null, 2);
   }
 };
-__name(Logger, "Logger");
+var JsonParser = _JsonParser;
+__name(JsonParser, "JsonParser");
+JsonParser.extensions = ["json"];
 
-// src/utils/logger/listr-logger.ts
-var ListrLogger = class extends import_listr22.Logger {
-  constructor(context) {
-    super();
-    this.logger = new Logger(context);
+// 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.");
   }
-  fail(message) {
-    this.logger.error(message);
+  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;
+    }
   }
-  skip(message) {
-    this.logger.warn(message, { status: "skip" });
+  stringify(data) {
+    return (0, import_yaml.stringify)(data, { prettyErrors: true });
   }
-  success(message) {
-    this.logger.info(message, { status: "end" });
+};
+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.");
+    }
   }
-  data(message) {
-    this.logger.info(message);
+  exists(path) {
+    return import_fs_extra.default.existsSync(path);
   }
-  start(message) {
-    this.logger.info(message, { status: "run" });
+  stats(path) {
+    return import_fs_extra.default.statSync(path, { throwIfNoEntry: true });
   }
-  title(message) {
-    this.logger.info(message);
+  dirname(path) {
+    return (0, import_path.dirname)(path);
   }
-  retry(message) {
-    this.logger.warn(message, { status: "retry" });
+  extname(path) {
+    return (0, import_path.extname)(path);
   }
-  rollback(message) {
-    this.logger.error(message, { status: "rollback" });
-  }
-};
-__name(ListrLogger, "ListrLogger");
-
-// src/utils/logger/pipe/pipe-process-to-listr.ts
-var import_through = __toESM(require("through"));
-function pipeProcessThroughListr(task, instance) {
-  const logOut = (0, import_through.default)((chunk) => {
-    task.output = chunk?.toString("utf-8").trim();
-  });
-  instance.stdout.pipe(logOut);
-  instance.stderr.pipe(logOut);
-  return instance;
-}
-__name(pipeProcessThroughListr, "pipeProcessThroughListr");
-
-// src/utils/logger/pipe/pipe-process-to-logger.ts
-var import_through2 = __toESM(require("through"));
-function pipeProcessToLogger(logger, instance, options) {
-  options = {
-    start: "INFO" /* INFO */,
-    end: "INFO" /* INFO */,
-    stdout: "INFO" /* INFO */,
-    stderr: "WARN" /* WARN */,
-    ...options
-  };
-  if (options.start) {
-    logger.run(instance.spawnargs.join(" "), { level: options.start });
-  }
-  if (instance.stdout) {
-    instance.stdout.pipe(
-      (0, import_through2.default)((chunk) => {
-        logger.log(options.stdout, chunk);
-      })
-    );
-  }
-  if (instance.stderr) {
-    instance.stderr.pipe(
-      (0, import_through2.default)((chunk) => {
-        logger.log(options.stderr, chunk);
-      })
-    );
-  }
-  void instance.on("exit", (code, signal) => {
-    const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
-    logger.debug(message);
-    if (options.end) {
-      logger.end(instance.spawnargs.join(" "), { level: options.end });
-    }
-    if (options?.callback) {
-      options.callback();
-    }
-  });
-  void instance.on("error", (error) => {
-    logger.fatal(error.message);
-    logger.debug(error.stack);
-    if (options?.callback) {
-      options.callback(error);
-    }
-  });
-  return instance;
-}
-__name(pipeProcessToLogger, "pipeProcessToLogger");
-
-// 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/config/config.service.ts
-var import_object_path_immutable = __toESM(require("object-path-immutable"));
-var import_path2 = require("path");
-
-// 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}`);
-    }
+  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 {
@@ -535,14 +296,28 @@ var FileSystemService = class {
     try {
       await import_fs_extra.default.emptyDir(directory);
     } catch (e) {
-      throw new Error(`Error while deleting the directory "${directory}": ${e.message}`);
+      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 deleting the directory "${directory}": ${e.message}`);
+      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) {
@@ -565,7 +340,7 @@ __name(FileSystemService, "FileSystemService");
 // src/lib/parser/parser.service.ts
 var ParserService = class {
   constructor(parsers) {
-    this.parsers = [YamlParser, JsonParser];
+    this.parsers = [YamlParser, JsonParser, EnvironmentVariableParser];
     if (ParserService.instance) {
       return ParserService.instance;
     } else {
@@ -579,8 +354,8 @@ var ParserService = class {
     }
   }
   getParser(file) {
-    const ext = file.includes(".") ? this.fs.extname(file) : file;
-    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext.replace(/^\./, "")));
+    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}`);
     }
@@ -588,9 +363,17 @@ var ParserService = class {
   }
   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));
@@ -599,16 +382,22 @@ var ParserService = class {
     return this.fs.write(file, await this.stringify(file, data));
   }
   parse(file, data) {
-    const Parser = this.getParser(file);
-    return Parser.parse(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);
-    return Parser.stringify(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 */;
@@ -632,14 +421,16 @@ var MergeStrategy = /* @__PURE__ */ ((MergeStrategy2) => {
 
 // src/utils/merge.ts
 var import_deepmerge = __toESM(require("deepmerge"));
-function merge(strategy, target, ...source) {
-  return source.reduce((o, val) => {
-    return (0, import_deepmerge.default)(o, val ?? {}, {
-      arrayMerge: strategy === "EXTEND" /* EXTEND */ ? (destinationArray, sourceArray) => [...destinationArray, ...sourceArray] : (_, sourceArray) => sourceArray
-    });
-  }, target);
+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/defaults.ts
 function setCtxDefaults(ctx, ...defaults) {
@@ -707,7 +498,7 @@ var ConfigService = class {
     if (configs.length === 0) {
       throw new Error("Nothing to merge, configuration files are empty.");
     }
-    return merge(strategy, configs.some((config) => Array.isArray(config)) ? [] : {}, ...configs);
+    return merge(strategy, ...configs);
   }
   async env(definition, config) {
     const env = typeof definition === "string" ? await this.parser.read(definition) : definition;
@@ -809,8 +600,12 @@ var LockerService = class {
     this.root = root;
     this.toLock = [];
     this.toUnlock = [];
-    this.logger = new Logger(context ?? this.constructor.name);
     this.fs = new FileSystemService();
+    this.logger = new Logger(context ?? this.constructor.name);
+    if (!this.parser) {
+      const parser2 = new ParserService();
+      this.parser = parser2.getParser(file);
+    }
   }
   hasLock() {
     return this.toLock.length > 0;
@@ -842,200 +637,487 @@ var LockerService = class {
   }
   async lock(...data) {
     let lock = await this.tryRead() ?? {};
-    await Promise.all(
-      data.map(async (d) => {
+    data.forEach((d) => {
+      if (d?.enabled === false) {
+        return;
+      } else if (!d?.data || Array.isArray(d?.data) && d.data.length === 0 || typeof d?.data === "object" && Object.keys(d.data).length === 0) {
+        return;
+      }
+      const path = this.buildPath(d);
+      if (d?.merge) {
+        let parsed;
+        if (typeof d.data === "object") {
+          parsed = merge(d.merge, import_object_path_immutable2.default.get(lock, path, Array.isArray(d.data) ? [] : {}), d.data);
+        } else {
+          this.logger.warn('"%s" path with type "%s" is not mergeable.', path, typeof d.data);
+          parsed = d.data;
+        }
+        lock = import_object_path_immutable2.default.set(lock, path, parsed);
+        this.logger.verbose("Merge lock: %s -> %o", path, d.data);
+      } else {
+        lock = import_object_path_immutable2.default.set(lock, path, d.data);
+        this.logger.verbose("Override lock: %s -> %o", path, d.data);
+      }
+    });
+    await this.write(lock);
+  }
+  async unlock(...data) {
+    let lock = await this.tryRead();
+    if (!lock) {
+      this.logger.verbose("Lock file not found. Nothing to unlock.");
+      return;
+    }
+    if (data.length > 0) {
+      data.forEach((d) => {
         if (d?.enabled === false) {
           return;
-        } else if (!d?.data || Array.isArray(d?.data) && d.data.length === 0 || typeof d?.data === "object" && Object.keys(d.data).length === 0) {
-          return;
         }
         const path = this.buildPath(d);
-        if (d?.merge) {
-          let parsed;
-          if (typeof d.data === "object") {
-            parsed = merge(d.merge, import_object_path_immutable2.default.get(lock, path) || Array.isArray(d.data) ? [] : {}, d.data);
+        lock = import_object_path_immutable2.default.del(lock, path);
+        this.logger.verbose("Unlocked: %s", path);
+        for (let i = path.length - 1; i >= 0; i--) {
+          const parentPath = path.slice(0, i);
+          const parent = import_object_path_immutable2.default.get(lock, parentPath);
+          if (!parent || Array.isArray(parent) && parent.length === 0 || typeof parent === "object" && Object.keys(parent).length === 0) {
+            this.logger.verbose("Unlocked parent: %s -> %s", path, parentPath);
+            lock = import_object_path_immutable2.default.del(lock, parentPath);
           } else {
-            this.logger.warn('"%s" path with type "%s" is not mergeable.', path, typeof d.data);
-            parsed = d.data;
+            break;
           }
-          lock = import_object_path_immutable2.default.set(lock, path, parsed);
-          this.logger.verbose("Merge lock: %s -> %o", path, parsed);
-        } else {
-          lock = import_object_path_immutable2.default.set(lock, path, d.data);
-          this.logger.verbose("Override lock: %s -> %o", path, d.data);
         }
-      })
-    );
-    await this.write(lock);
-  }
-  async unlock(...data) {
-    let lock = await this.tryRead();
-    if (!lock) {
-      this.logger.verbose("Lock file not found. Nothing to unlock.");
-      return;
-    }
-    if (data.length > 0) {
-      await Promise.all(
-        data.map(async (d) => {
-          if (d?.enabled === false) {
-            return;
-          }
-          const path = this.buildPath(d);
-          lock = import_object_path_immutable2.default.del(lock, path);
-          this.logger.verbose("Unlocked: %s", path);
-        })
-      );
-    } else {
-      lock = import_object_path_immutable2.default.del(lock, this.root);
-      this.logger.verbose("Unlocked module: %s", this.root);
-    }
-    await this.write(lock);
-  }
-  async read() {
-    return this.parser.parse(await this.fs.read(this.file));
-  }
-  async tryRead() {
-    try {
-      return this.parser.parse(await this.fs.read(this.file));
-    } catch {
-      this.logger.trace("Can not read lockfile: %s", this.file);
-    }
-  }
-  async write(data) {
-    return this.fs.write(this.file, this.parser.stringify(data));
-  }
-  buildPath(d) {
-    if (d?.root !== true && this.root) {
-      return [this.root, ...this.normalizePath(d.path)];
+      });
+    } else {
+      lock = import_object_path_immutable2.default.del(lock, this.root);
+      this.logger.verbose("Unlocked module: %s", this.root);
+    }
+    await this.write(lock ?? {});
+  }
+  async read() {
+    return this.parser.parse(await this.fs.read(this.file));
+  }
+  async tryRead() {
+    try {
+      return this.parser.parse(await this.fs.read(this.file));
+    } catch {
+      this.logger.trace("Can not read lockfile: %s", this.file);
+    }
+  }
+  async write(data) {
+    if (!data || Array.isArray(data) && data.length === 0 || typeof data === "object" && Object.keys(data).length === 0) {
+      this.logger.trace("Trying to write empty lock file, deleting it instead: %s", this.file);
+      return this.fs.remove(this.file);
+    }
+    return this.fs.write(this.file, this.parser.stringify(data));
+  }
+  buildPath(d) {
+    if (d?.root !== true && this.root?.length) {
+      return [...this.root, ...this.normalizePath(d.path)];
+    }
+    return this.normalizePath(d.path);
+  }
+  normalizePath(path) {
+    if (Array.isArray(path)) {
+      return path.map((p) => p.toString());
+    } else if (typeof path === "string") {
+      return path.split(".");
+    }
+    return [];
+  }
+};
+__name(LockerService, "LockerService");
+
+// src/lib/store/store.service.ts
+var StoreService = class {
+  constructor() {
+    this.store = {};
+    if (StoreService.instance) {
+      return StoreService.instance;
+    } else {
+      StoreService.instance = this;
+    }
+  }
+  has(key) {
+    return !!this.store[key];
+  }
+  get(key) {
+    return this.store[key];
+  }
+  set(key, data) {
+    this.store[key] = data;
+    return data;
+  }
+};
+__name(StoreService, "StoreService");
+
+// src/lib/validator/validator.service.ts
+var import_class_transformer = require("class-transformer");
+var import_class_validator = require("class-validator");
+var ValidatorService = class {
+  constructor(options) {
+    this.options = options;
+    if (ValidatorService.instance) {
+      return ValidatorService.instance;
+    }
+    this.options = {
+      validator: {
+        skipMissingProperties: true,
+        whitelist: false,
+        always: true,
+        enableDebugMessages: true
+      },
+      transformer: { enableImplicitConversion: true },
+      ...options ?? {}
+    };
+    this.logger = new Logger(this.constructor.name);
+    ValidatorService.instance = this;
+    this.logger.trace("Created a new instance.");
+  }
+  async validate(classType, object, options) {
+    const classObject = (0, import_class_transformer.plainToClass)(classType, object, { ...this.options.transformer, ...options.transformer ?? {} });
+    const errors = await (0, import_class_validator.validate)(classObject, { ...this.options.validator, ...options.validator ?? {} });
+    if (errors.length) {
+      errors.forEach((error) => {
+        this.logValidationError(error);
+      });
+      throw new Error("Validation failed.");
+    }
+    return classObject;
+  }
+  validateSync(classType, object, options) {
+    const classObject = (0, import_class_transformer.plainToClass)(classType, object, { ...this.options.transformer, ...options.transformer ?? {} });
+    const errors = (0, import_class_validator.validateSync)(classObject, { ...this.options.validator, ...options.validator ?? {} });
+    if (errors.length) {
+      errors.forEach((error) => {
+        this.logValidationError(error);
+      });
+      throw new Error("Validation failed.");
+    }
+    return classObject;
+  }
+  logValidationError(err) {
+    this.logger.error('Field "%s" failed validation with value "%s": %s', err.property, err.value, Object.values(err.constraints).join(", "));
+  }
+};
+__name(ValidatorService, "ValidatorService");
+
+// src/lib/setup.ts
+function setup() {
+  const inspect = process.argv.indexOf("--inspect");
+  if (inspect !== -1) {
+    require("inspector").open();
+    process.argv.splice(inspect, 1);
+  }
+  const verbose = process.argv.indexOf("--verbose");
+  if (verbose !== -1) {
+    process.env.LOG_LEVEL = "verbose";
+    process.argv.splice(verbose, 1);
+  }
+  const debug = process.argv.indexOf("--debug");
+  if (debug !== -1) {
+    process.env.LOG_LEVEL = "debug";
+    process.argv.splice(debug, 1);
+  }
+  const trace = process.argv.indexOf("--trace");
+  if (trace !== -1) {
+    process.env.LOG_LEVEL = "trace";
+    process.argv.splice(trace, 1);
+  }
+  const silent = process.argv.indexOf("--silent");
+  if (silent !== -1) {
+    process.env.LOG_LEVEL = "silent";
+    process.argv.splice(silent, 1);
+  }
+  const sourceMaps = process.argv.indexOf("--source-map");
+  if (sourceMaps !== -1) {
+    require("source-map-support").install();
+    process.argv.splice(sourceMaps, 1);
+  }
+}
+__name(setup, "setup");
+
+// 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;
     }
-    return this.normalizePath(d.path);
-  }
-  normalizePath(path) {
-    if (Array.isArray(path)) {
-      return path;
-    } else if (typeof path === "string") {
-      return path.split(".");
+    if (!icon) {
+      icon = `[${level.at(0).toUpperCase()}]`;
     }
-    return [];
+    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
   }
 };
-__name(LockerService, "LockerService");
+__name(Logger, "Logger");
 
-// src/lib/store/store.service.ts
-var StoreService = class {
-  constructor() {
-    this.store = {};
-    if (StoreService.instance) {
-      return StoreService.instance;
-    } else {
-      StoreService.instance = this;
-    }
+// src/utils/logger/listr-logger.ts
+var ListrLogger = class extends import_listr22.Logger {
+  constructor(context) {
+    super();
+    this.logger = new Logger(context);
   }
-  has(key) {
-    return !!this.store[key];
+  fail(message) {
+    this.logger.error(message);
   }
-  get(key) {
-    return this.store[key];
+  skip(message) {
+    this.logger.warn(message, { status: "skip" });
   }
-  set(key, data) {
-    this.store[key] = data;
-    return data;
+  success(message) {
+    this.logger.info(message, { status: "end" });
   }
-};
-__name(StoreService, "StoreService");
-
-// src/lib/validator/validator.service.ts
-var import_class_transformer = require("class-transformer");
-var import_class_validator = require("class-validator");
-var ValidatorService = class {
-  constructor(options) {
-    this.options = options;
-    if (ValidatorService.instance) {
-      return ValidatorService.instance;
-    }
-    this.options = {
-      validator: {
-        skipMissingProperties: true,
-        whitelist: false,
-        always: true,
-        enableDebugMessages: true
-      },
-      transformer: { enableImplicitConversion: true },
-      ...options ?? {}
-    };
-    this.logger = new Logger(this.constructor.name);
-    ValidatorService.instance = this;
-    this.logger.trace("Created a new instance.");
+  data(message) {
+    this.logger.info(message);
   }
-  async validate(classType, object, options) {
-    const classObject = (0, import_class_transformer.plainToClass)(classType, object, { ...this.options.transformer, ...options.transformer ?? {} });
-    const errors = await (0, import_class_validator.validate)(classObject, { ...this.options.validator, ...options.validator ?? {} });
-    if (errors.length) {
-      errors.forEach((error) => {
-        this.logValidationError(error);
-      });
-      throw new Error("Validation failed.");
-    }
-    return classObject;
+  start(message) {
+    this.logger.info(message, { status: "run" });
   }
-  validateSync(classType, object, options) {
-    const classObject = (0, import_class_transformer.plainToClass)(classType, object, { ...this.options.transformer, ...options.transformer ?? {} });
-    const errors = (0, import_class_validator.validateSync)(classObject, { ...this.options.validator, ...options.validator ?? {} });
-    if (errors.length) {
-      errors.forEach((error) => {
-        this.logValidationError(error);
-      });
-      throw new Error("Validation failed.");
-    }
-    return classObject;
+  title(message) {
+    this.logger.info(message);
   }
-  logValidationError(err) {
-    this.logger.error('Field "%s" failed validation with value "%s": %s', err.property, err.value, Object.values(err.constraints).join(", "));
+  retry(message) {
+    this.logger.warn(message, { status: "retry" });
+  }
+  rollback(message) {
+    this.logger.error(message, { status: "rollback" });
   }
 };
-__name(ValidatorService, "ValidatorService");
+__name(ListrLogger, "ListrLogger");
 
-// src/lib/setup.ts
-function setup() {
-  const inspect = process.argv.indexOf("--inspect");
-  if (inspect !== -1) {
-    require("inspector").open();
-    process.argv.splice(inspect, 1);
-  }
-  const verbose = process.argv.indexOf("--verbose");
-  if (verbose !== -1) {
-    process.env.LOG_LEVEL = "verbose";
-    process.argv.splice(verbose, 1);
-  }
-  const debug = process.argv.indexOf("--debug");
-  if (debug !== -1) {
-    process.env.LOG_LEVEL = "debug";
-    process.argv.splice(debug, 1);
-  }
-  const trace = process.argv.indexOf("--trace");
-  if (trace !== -1) {
-    process.env.LOG_LEVEL = "trace";
-    process.argv.splice(trace, 1);
+// src/utils/logger/pipe/pipe-process-to-listr.ts
+var import_through = __toESM(require("through"));
+function pipeProcessThroughListr(task, instance) {
+  const logOut = (0, import_through.default)((chunk) => {
+    task.output = chunk?.toString("utf-8").trim();
+  });
+  instance.stdout.pipe(logOut);
+  instance.stderr.pipe(logOut);
+  return instance;
+}
+__name(pipeProcessThroughListr, "pipeProcessThroughListr");
+
+// src/utils/logger/pipe/pipe-process-to-logger.ts
+var import_through2 = __toESM(require("through"));
+function pipeProcessToLogger(logger, instance, options) {
+  options = {
+    start: "INFO" /* INFO */,
+    end: "INFO" /* INFO */,
+    stdout: "INFO" /* INFO */,
+    stderr: "WARN" /* WARN */,
+    ...options
+  };
+  if (options.start) {
+    logger.run(instance.spawnargs.join(" "), { level: options.start });
   }
-  const silent = process.argv.indexOf("--silent");
-  if (silent !== -1) {
-    process.env.LOG_LEVEL = "silent";
-    process.argv.splice(silent, 1);
+  if (instance.stdout) {
+    instance.stdout.pipe(
+      (0, import_through2.default)((chunk) => {
+        logger.log(options.stdout, chunk);
+      })
+    );
   }
-  const sourceMaps = process.argv.indexOf("--source-map");
-  if (sourceMaps !== -1) {
-    require("source-map-support").install();
-    process.argv.splice(sourceMaps, 1);
+  if (instance.stderr) {
+    instance.stderr.pipe(
+      (0, import_through2.default)((chunk) => {
+        logger.log(options.stderr, chunk);
+      })
+    );
   }
+  void instance.on("exit", (code, signal) => {
+    const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
+    logger.debug(message);
+    if (options.end) {
+      logger.end(instance.spawnargs.join(" "), { level: options.end });
+    }
+    if (options?.callback) {
+      options.callback();
+    }
+  });
+  void instance.on("error", (error) => {
+    logger.fatal(error.message);
+    logger.debug(error.stack);
+    if (options?.callback) {
+      options.callback(error);
+    }
+  });
+  return instance;
 }
-__name(setup, "setup");
+__name(pipeProcessToLogger, "pipeProcessToLogger");
+
+// 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/commands/base.command.ts
 var Command = class extends import_core3.Command {
-  constructor(argv, config) {
-    super(argv, config);
-    this.argv = argv;
-    this.config = config;
+  constructor() {
+    super(...arguments);
     this.flags = {};
     this.args = {};
   }
@@ -1059,10 +1141,9 @@ var Command = class extends import_core3.Command {
       delete process.env[this.config.scopedEnvVarKey("REDIRECTED")];
       await this.init();
       result = await this.run();
-    } catch (error) {
-      await this.catch(error);
-    } finally {
       await this.finally();
+    } catch (error) {
+      await this.catch(error, 127);
     }
     if (result && this.jsonEnabled()) {
       import_core2.CliUx.ux.styledJSON(this.toSuccessJson(result));
@@ -1078,19 +1159,17 @@ var Command = class extends import_core3.Command {
   }
   prompt(options) {
     return (0, import_listr23.createPrompt)(options, {
-      stdout: process.stdout,
-      cancelCallback: () => {
-        throw new Error("Cancelled prompt.");
-      }
+      error: true,
+      stdout: process.stdout
     });
   }
   setCtxDefaults(...defaults) {
     setCtxDefaults(this.tasks.options.ctx, ...defaults);
-    this.logger.trace("updated  with defaults: %o", this.tasks.options.ctx, { status: "ctx" });
+    this.logger.trace("Updated context with defaults: %o", this.tasks.options.ctx, { status: "ctx" });
   }
   setCtxAssign(...assigns) {
     setCtxAssign(this.tasks.options.ctx, ...assigns);
-    this.logger.trace("updated with assign: %o", this.tasks.options.ctx, { status: "ctx" });
+    this.logger.trace("Updated context with assign: %o", this.tasks.options.ctx, { status: "ctx" });
   }
   async init() {
     await super.init();
@@ -1137,10 +1216,12 @@ var Command = class extends import_core3.Command {
         process.kill(process.pid, "SIGINT");
       });
     }
-    process.on("SIGINT", () => {
+    const terminate = /* @__PURE__ */ __name(() => {
       this.logger.fatal("Caught terminate signal.", { status: "terminate" /* TERMINATE */ });
       process.exit(1);
-    });
+    }, "terminate");
+    process.on("SIGINT", terminate);
+    process.on("SIGTERM", terminate);
     this.logger.stage("Running shouldRunBefore.");
     await this.shouldRunBefore();
     this.logger.stage("Finished shouldRunBefore.");
@@ -1154,10 +1235,12 @@ var Command = class extends import_core3.Command {
     this.logger.stage("Finished shouldRunAfter.");
     return { ctx };
   }
-  catch(e) {
+  catch(e, exit) {
     this.logger.fatal(e.message);
     this.logger.debug(e.stack, { context: "crash" });
-    this.exit(127);
+    if (exit > 0) {
+      this.exit(exit);
+    }
     return;
   }
   greet() {
@@ -1234,6 +1317,7 @@ var storeHook = /* @__PURE__ */ __name((cb) => async (opts) => {
   Command,
   ConfigCommand,
   ConfigService,
+  EnvironmentVariableParser,
   FileConstants,
   FileSystemService,
   Flags,
@@ -1262,5 +1346,6 @@ var storeHook = /* @__PURE__ */ __name((cb) => async (opts) => {
   setCtxDefaults,
   setup,
   storeHook,
+  uniqueFilter,
   updateNotifierHook
 });