juisy 2.0.0-beta.14 → 2.0.0-beta.16

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 /*!
- * juisy v2.0.0-beta.14
+ * juisy v2.0.0-beta.16
  * Copyright © 2022-Present Hervé Perchec
  */
 
@@ -11,19 +11,19 @@ import Yargs from 'yargs/yargs';
 import { findUpSync } from 'find-up';
 import { importSingleTs } from 'import-single-ts';
 import lodashGet from 'lodash.get';
-import { execa } from 'execa';
-import _prompts from 'prompts';
 import chalk from 'chalk';
 import indent from 'indent-string';
 import _stripAnsi from 'strip-ansi';
+import { execa } from 'execa';
+import _prompts from 'prompts';
 import dotenv from '@dotenvx/dotenvx';
 import semver from 'semver';
-import { getPackageInfo } from 'juisy';
+import fs$1 from 'node:fs';
+import path from 'node:path';
 import kebabcase from 'lodash.kebabcase';
 import { ReadmeTemplater } from 'juisy/templater';
-import path from 'node:path';
+import { getPackageInfo } from 'juisy';
 import { ESLint } from 'eslint';
-import fs$1 from 'node:fs';
 import yargsParser from 'yargs-parser';
 
 class Plugin {
@@ -56,6 +56,285 @@ class Plugin {
   created;
 }
 
+const loading = {
+  // Duration of each character displaying (in ms)
+  velocity: 250,
+  // Reference to call setInterval and clearInterval
+  intervalRef: null,
+  // Display loading to STDOUT
+  display: function(message) {
+    const P = ["\\", "|", "/", "-"];
+    const S = ["   ", ".  ", ".. ", "..."];
+    let x = 0;
+    let y = 0;
+    const velocity = this.velocity;
+    this.intervalRef = setInterval(function() {
+      process.stdout.write("\r" + P[x++] + " " + message + " : " + S[y++]);
+      x &= 3;
+      y &= 3;
+    }, velocity);
+  },
+  stop: function() {
+    clearInterval(this.intervalRef);
+    try {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+    } catch (err) {
+      console.log("Warn: process.stdout.clearLine (or cursorTo) function is non-TTY. Skipped...");
+    }
+  }
+};
+class OutputUtils {
+  /**
+   * To automatically increment step index
+   * @ignore
+   */
+  static stepsCache = {
+    index: 0
+    // 0 by default
+  };
+  /**
+   * Use `chalk` package to style output in console/stdout
+   * @example
+   * const { $style } = OutputUtils
+   * console.log($style.green('Green text!')) // => '[32mGreen text![0m'
+   */
+  static $style = chalk;
+  /**
+   * Format a message for console output
+   * @param msg - The message to format
+   * @param options - Format options
+   * @returns The formatted message
+   * @example
+   * formatOutputMessage('laundry\nshopping', { indentChar: '- ' })
+   * // => '- laundry\n- shopping'
+   *
+   * formatOutputMessage('foo\nbar', { indent: 2, indentChar: '❤' })
+   * // => '❤❤foo\n❤❤bar'
+   */
+  static formatOutputMessage(msg, options = {}) {
+    let formatted = `${msg}`;
+    if (options.indentChar) {
+      if (options.indent === void 0) {
+        options.indent = 1;
+      }
+    } else {
+      options.indentChar = " ";
+      options.indent = options.indent || 0;
+    }
+    if (options.indent) {
+      formatted = indent(msg, options.indent, { indent: options.indentChar });
+    }
+    return formatted;
+  }
+  /**
+   * @param msg - The message
+   * @param options - (Optional) Options object
+   * @param options.indent - How many repeat indent (see `indent-string` package)
+   * @param options.indentChar - Indent character(s). If `options.indent` not provided, will be repeated only 1 time
+   * @description
+   * Log message in console
+   * @example
+   * const { log } = OutputUtils
+   * log() // => blank line
+   * log('Hello world! =)') // => 'Hello world! =)'
+   * log('To do:', { indent: 2 }) // => '  To do:'
+   */
+  static log(msg, options = {}) {
+    const loggerInstance = options.loggerInstance || console;
+    if (msg) {
+      loggerInstance.log(OutputUtils.formatOutputMessage(msg, options));
+    } else {
+      loggerInstance.log();
+    }
+  }
+  /**
+   * Display warning message
+   * @param msg - The message to display
+   * @example
+   * const { warn } = OutputUtils
+   * warn('No configuration file') // => '[33m⚠ Warning: No configuration file[0m'
+   */
+  static warn(msg) {
+    OutputUtils.log(OutputUtils.$style.yellow(`⚠ Warning: ${msg}`));
+  }
+  /**
+   * @param msg - The message to display
+   * @param err - If provided, throw the error
+   * @description
+   * Display error message. Throws `err` if provided.
+   * @example
+   * const { error } = require('@hperchec/juisy').utils
+   * error('No configuration file') // => '[31m⨉ ERROR: No configuration file[0m'
+   * error('No configuration file', error) // => Log and throws error
+   */
+  static error(msg, err) {
+    OutputUtils.log(OutputUtils.$style.red(`⨉ ERROR: ${msg}`));
+    if (err !== void 0) {
+      OutputUtils.log();
+      throw err;
+    }
+  }
+  /**
+   * Log step title
+   * @param msg - The message to display
+   * @param options - Options object
+   * @param options.index - Custom index. If `null`, no index prepended to string
+   * @example
+   * step('Important step') // => '● 1 - Important step'
+   * step('Very important step') // => '● 2 - Very important step'
+   */
+  static step(msg, options = {}) {
+    OutputUtils.stepsCache.index++;
+    if (options.index === void 0) {
+      options.index = OutputUtils.stepsCache.index;
+    }
+    OutputUtils.log(`${options.index !== null ? options.index + " - " : ""}${msg}`, { indentChar: "● " });
+  }
+  /**
+   * Log substep title
+   * @param msg - The message to display
+   * @param options - Options object
+   * @param options.last - Defines if it is the last substep
+   * @example
+   * const { substep } = require('@hperchec/juisy').utils
+   * substep('Awesome substep') // => '├ Awesome substep'
+   * substep('Last substep', { last: true }) // => '└ Last substep'
+   */
+  static substep(msg, options = {}) {
+    OutputUtils.log(msg, { indentChar: options.last ? "└ " : "├ " });
+  }
+  /**
+   * @param {string} message - Message to display
+   * @param {Function} fct - The function to execute
+   * @returns {Promise<void>}
+   * @description
+   * Wait function: display loading during 'fct' execution
+   * @example
+   * const { wait } = require('@hperchec/juisy').utils
+   * await wait('Waiting', async () => {
+   *   // Do async logic
+   * })
+   */
+  static async wait(message, fct) {
+    loading.display(message);
+    await fct();
+    loading.stop();
+  }
+  /**
+   * See `strip-ansi` package documentation
+   * @see https://www.npmjs.com/package/strip-ansi
+   */
+  static stripAnsi = _stripAnsi;
+}
+
+class Command {
+  /**
+   * Creates a Command instance from object (CommandObject)
+   * @param {CommandObject} commandObject - The command definition object
+   */
+  constructor(commandObject) {
+    if (commandObject) {
+      this.command = commandObject.command;
+      this.aliases = commandObject.aliases;
+      this.describe = commandObject.describe;
+      this.deprecated = commandObject.deprecated;
+      this.meta = commandObject.meta;
+      if (commandObject.builder)
+        this.builder = commandObject.builder;
+      if (commandObject.handler)
+        this.handler = commandObject.handler;
+      this.middlewares = commandObject.middlewares;
+    }
+  }
+  /**
+   * The command
+   */
+  command;
+  /**
+   * The aliases
+   */
+  aliases;
+  /**
+   * Command description
+   */
+  describe;
+  /**
+   * Is deprecated?
+   */
+  deprecated;
+  /**
+   * Command meta
+   */
+  meta;
+  /**
+   * Command builder
+   */
+  builder(cli) {
+    return cli;
+  }
+  /**
+   * Command handler
+   */
+  handler(argv) {
+    throw new Error("Command handler is not implemented");
+  }
+  /**
+   * Command middlewares
+   */
+  middlewares;
+  /**
+   * Log a message in the console output. Uses OutputUtils.log method.
+   * @param msg The message to log. Can be empty to log blank line
+   * @param options The options to pass to OutputUtils.log second argument
+   */
+  log(msg, options = {}) {
+    OutputUtils.log(msg, {
+      ...options,
+      loggerInstance: this.constructor.engine.getInternalMethods().getLoggerInstance()
+    });
+  }
+  /**
+   * Get the process.argv without bin
+   * @returns An array of command line arguments
+   */
+  getProcessArgv() {
+    return hideBin(process.argv);
+  }
+  /**
+   * Get Command instance as plain object
+   * @returns The command definition object to pass to yargs
+   */
+  toObject() {
+    return {
+      command: this.command,
+      aliases: this.aliases,
+      describe: this.describe,
+      deprecated: this.deprecated,
+      meta: this.meta,
+      builder: this.builder,
+      handler: this.handler.bind(this),
+      middlewares: this.middlewares
+    };
+  }
+  /**
+   * Getters
+   */
+  /**
+   * Get the CLI engine
+   */
+  get engine() {
+    return this.constructor.engine;
+  }
+  /**
+   * Static properties
+   */
+  /**
+   * The CLI engine. Will be set by createEngine method
+   */
+  static engine;
+}
+
 function createEngine(yargs) {
   const xargs = yargs;
   xargs._isPrivate = false;
@@ -78,7 +357,8 @@ function createEngine(yargs) {
   xargs.enableGlobalCommandVisitors = enableGlobalCommandVisitors;
   xargs.isPrivate = isPrivate;
   xargs.getSettings = getSettings;
-  return xargs.strict().help();
+  Command.engine = xargs.strict().help();
+  return Command.engine;
 }
 function command(...args) {
   const self = this;
@@ -96,10 +376,13 @@ function command(...args) {
       }
       return failOnFalsyReturn ? false : cmdObj;
     };
+    const isClass = (value) => {
+      return typeof value === "function" && value.toString().startsWith("class ");
+    };
     if (args[0] instanceof Array) {
       const cmdsArray = [];
       for (const commandModule of args[0]) {
-        const visited = visit(commandModule);
+        const visited = visit((isClass(commandModule) ? new commandModule() : commandModule).toObject());
         if (visited)
           cmdsArray.push(visited);
       }
@@ -196,367 +479,154 @@ const findCommandIn = (fullSignature, commands) => {
       return command;
     } else {
       if (command.children?.length) {
-        const found = findCommandIn(fullSignature, command.children);
-        if (found)
-          return found;
-      }
-    }
-  }
-};
-const getDefaultCommand = (fullSignature) => {
-  return findCommandIn(fullSignature, defaultCommands);
-};
-const resolveSettingsCallbacks = {
-  // ...
-};
-function defineSettings(target, settings, options) {
-  if (options?.resolve) {
-    resolveSettingsCallbacks[target] = options.resolve;
-  }
-  defaultGlobalSettings[target] = settings;
-}
-async function CLIFactory(builder, options) {
-  let settingsPath;
-  let globalSettings;
-  for (const plugin of registeredPlugins) {
-    await plugin.beforeCreate({
-      defineDefaultCommand,
-      defineSettings,
-      builder,
-      factoryOptions: options || {}
-    });
-  }
-  if (options?.settingsPath) {
-    settingsPath = options.settingsPath;
-  }
-  const configPath = findUpSync(settingsPath ? [settingsPath] : [
-    "dev.config.ts",
-    "dev.config.js",
-    "dev.config.json",
-    "cli.config.ts",
-    "cli.config.js",
-    "cli.config.json",
-    ".clirc.ts",
-    ".clirc.js",
-    ".clirc.json"
-  ]);
-  if (settingsPath && !configPath) {
-    throw new Error("Unable to find file: " + settingsPath);
-  } else if (configPath) {
-    if (configPath.endsWith(".ts")) {
-      globalSettings = deepmerge(defaultGlobalSettings, await importSingleTs(configPath).then((mod) => mod.default || mod));
-    } else if (configPath.endsWith(".json")) {
-      globalSettings = deepmerge(defaultGlobalSettings, JSON.parse(fs.readFileSync(configPath).toString()));
-    } else {
-      globalSettings = deepmerge(defaultGlobalSettings, await import(pathToFileURL(configPath).toString()).then((mod) => mod.default || mod));
-    }
-  } else {
-    globalSettings = defaultGlobalSettings;
-  }
-  const cli = function(argv) {
-    let engine = createEngine(Yargs(argv));
-    engine._settings = proxify(globalSettings);
-    for (const plugin of registeredPlugins) {
-      plugin.created({
-        engine,
-        builder,
-        factoryOptions: options || {}
-      });
-    }
-    engine = builder(engine);
-    const rootHandlers = engine.getInternalMethods().getCommandInstance().handlers;
-    for (const key in rootHandlers) {
-      const handler = rootHandlers[key];
-      if (defaultCommands.find((cmdObj) => cmdObj.fullSignature === handler.original)) {
-        engine.disableDefaultCommand(handler.original);
-      }
-    }
-    for (const defaultCommand of defaultCommands) {
-      if (engine.hasDefaultCommand(defaultCommand.fullSignature)) {
-        engine.command({
-          // @ts-ignore
-          aliases: defaultCommand.commandObject.aliases,
-          command: defaultCommand.commandObject.command,
-          describe: defaultCommand.commandObject.describe,
-          builder: (cli2) => {
-            return defaultCommand.commandObject.builder(cli2);
-          },
-          handler: defaultCommand.commandObject.handler,
-          meta: defaultCommand.commandObject.meta,
-          middlewares: defaultCommand.commandObject.middlewares
-        });
-      }
-    }
-    return engine;
-  };
-  return cli;
-}
-CLIFactory.use = function(plugin) {
-  if (plugin instanceof Plugin) {
-    if (registeredPlugins.find((rp) => rp.name === plugin.name)) {
-      throw new Error(`CLI plugin "${plugin.name}" is already used`);
-    } else {
-      registeredPlugins.push(plugin);
-    }
-  } else {
-    throw new Error(`Provided plugin is not an instance of Plugin`);
-  }
-};
-
-class Command {
-  /**
-   * Creates a Command instance from object (CommandObject)
-   * @param {CommandObject} commandObject - The command definition object
-   */
-  constructor(commandObject) {
-    this.command = commandObject.command;
-    this.aliases = commandObject.aliases;
-    this.describe = commandObject.describe;
-    this.deprecated = commandObject.deprecated;
-    this.meta = commandObject.meta;
-    this.builder = commandObject.builder || ((cli) => cli);
-    this.handler = commandObject.handler;
-    this.middlewares = commandObject.middlewares;
-  }
-  /**
-   * The command
-   */
-  command;
-  /**
-   * The aliases
-   */
-  aliases;
-  /**
-   * Command description
-   */
-  describe;
-  /**
-   * Is deprecated?
-   */
-  deprecated;
-  /**
-   * Command meta
-   */
-  meta;
-  /**
-   * Command builder
-   */
-  builder;
-  /**
-   * Command handler
-   */
-  // @ts-ignore
-  handler;
-  /**
-   * Command middlewares
-   */
-  middlewares;
-}
-
-const loading = {
-  // Duration of each character displaying (in ms)
-  velocity: 250,
-  // Reference to call setInterval and clearInterval
-  intervalRef: null,
-  // Display loading to STDOUT
-  display: function(message) {
-    const P = ["\\", "|", "/", "-"];
-    const S = ["   ", ".  ", ".. ", "..."];
-    let x = 0;
-    let y = 0;
-    const velocity = this.velocity;
-    this.intervalRef = setInterval(function() {
-      process.stdout.write("\r" + P[x++] + " " + message + " : " + S[y++]);
-      x &= 3;
-      y &= 3;
-    }, velocity);
-  },
-  stop: function() {
-    clearInterval(this.intervalRef);
-    try {
-      process.stdout.clearLine(0);
-      process.stdout.cursorTo(0);
-    } catch (err) {
-      console.log("Warn: process.stdout.clearLine (or cursorTo) function is non-TTY. Skipped...");
-    }
-  }
-};
-class OutputUtils {
-  /**
-   * To automatically increment step index
-   * @ignore
-   */
-  static stepsCache = {
-    index: 0
-    // 0 by default
-  };
-  /**
-   * Use `chalk` package to style output in console/stdout
-   * @example
-   * const { $style } = OutputUtils
-   * console.log($style.green('Green text!')) // => '[32mGreen text![0m'
-   */
-  static $style = chalk;
-  /**
-   * Format a message for console output
-   * @param msg - The message to format
-   * @param options - Format options
-   * @returns The formatted message
-   * @example
-   * formatOutputMessage('laundry\nshopping', { indentChar: '- ' })
-   * // => '- laundry\n- shopping'
-   *
-   * formatOutputMessage('foo\nbar', { indent: 2, indentChar: '❤' })
-   * // => '❤❤foo\n❤❤bar'
-   */
-  static formatOutputMessage(msg, options = {}) {
-    let formatted = `${msg}`;
-    if (options.indentChar) {
-      if (options.indent === void 0) {
-        options.indent = 1;
+        const found = findCommandIn(fullSignature, command.children);
+        if (found)
+          return found;
       }
-    } else {
-      options.indentChar = " ";
-      options.indent = options.indent || 0;
-    }
-    if (options.indent) {
-      formatted = indent(msg, options.indent, { indent: options.indentChar });
     }
-    return formatted;
   }
-  /**
-   * @param msg - The message
-   * @param options - (Optional) Options object
-   * @param options.indent - How many repeat indent (see `indent-string` package)
-   * @param options.indentChar - Indent character(s). If `options.indent` not provided, will be repeated only 1 time
-   * @description
-   * Log message in console
-   * @example
-   * const { log } = OutputUtils
-   * log() // => blank line
-   * log('Hello world! =)') // => 'Hello world! =)'
-   * log('To do:', { indent: 2 }) // => '  To do:'
-   */
-  static log(msg, options = {}) {
-    const loggerInstance = options.loggerInstance || console;
-    if (msg) {
-      loggerInstance.log(OutputUtils.formatOutputMessage(msg, options));
-    } else {
-      loggerInstance.log();
-    }
+};
+const getDefaultCommand = (fullSignature) => {
+  return findCommandIn(fullSignature, defaultCommands);
+};
+const resolveSettingsCallbacks = {
+  // ...
+};
+function defineSettings(target, settings, options) {
+  if (options?.resolve) {
+    resolveSettingsCallbacks[target] = options.resolve;
   }
-  /**
-   * Display warning message
-   * @param msg - The message to display
-   * @example
-   * const { warn } = OutputUtils
-   * warn('No configuration file') // => '[33m⚠ Warning: No configuration file[0m'
-   */
-  static warn(msg) {
-    OutputUtils.log(OutputUtils.$style.yellow(`⚠ Warning: ${msg}`));
+  defaultGlobalSettings[target] = settings;
+}
+async function CLIFactory(builder, options) {
+  let settingsPath;
+  let globalSettings;
+  for (const plugin of registeredPlugins) {
+    await plugin.beforeCreate({
+      defineDefaultCommand,
+      defineSettings,
+      builder,
+      factoryOptions: options || {}
+    });
   }
-  /**
-   * @param msg - The message to display
-   * @param err - If provided, throw the error
-   * @description
-   * Display error message. Throws `err` if provided.
-   * @example
-   * const { error } = require('@hperchec/juisy').utils
-   * error('No configuration file') // => '[31m⨉ ERROR: No configuration file[0m'
-   * error('No configuration file', error) // => Log and throws error
-   */
-  static error(msg, err) {
-    OutputUtils.log(OutputUtils.$style.red(`⨉ ERROR: ${msg}`));
-    if (err !== void 0) {
-      OutputUtils.log();
-      throw err;
-    }
+  if (options?.settingsPath) {
+    settingsPath = options.settingsPath;
   }
-  /**
-   * Log step title
-   * @param msg - The message to display
-   * @param options - Options object
-   * @param options.index - Custom index. If `null`, no index prepended to string
-   * @example
-   * step('Important step') // => '● 1 - Important step'
-   * step('Very important step') // => '● 2 - Very important step'
-   */
-  static step(msg, options = {}) {
-    OutputUtils.stepsCache.index++;
-    if (options.index === void 0) {
-      options.index = OutputUtils.stepsCache.index;
+  const configPath = findUpSync(settingsPath ? [settingsPath] : [
+    "dev.config.ts",
+    "dev.config.js",
+    "dev.config.json",
+    "cli.config.ts",
+    "cli.config.js",
+    "cli.config.json",
+    ".clirc.ts",
+    ".clirc.js",
+    ".clirc.json"
+  ]);
+  if (settingsPath && !configPath) {
+    throw new Error("Unable to find file: " + settingsPath);
+  } else if (configPath) {
+    if (configPath.endsWith(".ts")) {
+      globalSettings = deepmerge(defaultGlobalSettings, await importSingleTs(configPath).then((mod) => mod.default || mod));
+    } else if (configPath.endsWith(".json")) {
+      globalSettings = deepmerge(defaultGlobalSettings, JSON.parse(fs.readFileSync(configPath).toString()));
+    } else {
+      globalSettings = deepmerge(defaultGlobalSettings, await import(pathToFileURL(configPath).toString()).then((mod) => mod.default || mod));
     }
-    OutputUtils.log(`${options.index !== null ? options.index + " - " : ""}${msg}`, { indentChar: "● " });
+  } else {
+    globalSettings = defaultGlobalSettings;
   }
-  /**
-   * Log substep title
-   * @param msg - The message to display
-   * @param options - Options object
-   * @param options.last - Defines if it is the last substep
-   * @example
-   * const { substep } = require('@hperchec/juisy').utils
-   * substep('Awesome substep') // => '├ Awesome substep'
-   * substep('Last substep', { last: true }) // => '└ Last substep'
-   */
-  static substep(msg, options = {}) {
-    OutputUtils.log(msg, { indentChar: options.last ? "└ " : "├ " });
+  const cli = function(argv) {
+    let engine = createEngine(Yargs(argv));
+    engine._settings = proxify(globalSettings);
+    for (const plugin of registeredPlugins) {
+      plugin.created({
+        engine,
+        builder,
+        factoryOptions: options || {}
+      });
+    }
+    engine = builder(engine);
+    const rootHandlers = engine.getInternalMethods().getCommandInstance().handlers;
+    for (const key in rootHandlers) {
+      const handler = rootHandlers[key];
+      if (defaultCommands.find((cmdObj) => cmdObj.fullSignature === handler.original)) {
+        engine.disableDefaultCommand(handler.original);
+      }
+    }
+    for (const defaultCommand of defaultCommands) {
+      if (engine.hasDefaultCommand(defaultCommand.fullSignature)) {
+        engine.command(defaultCommand.commandObject.toObject());
+      }
+    }
+    return engine;
+  };
+  return cli;
+}
+CLIFactory.use = function(plugin) {
+  if (plugin instanceof Plugin) {
+    if (registeredPlugins.find((rp) => rp.name === plugin.name)) {
+      throw new Error(`CLI plugin "${plugin.name}" is already used`);
+    } else {
+      registeredPlugins.push(plugin);
+    }
+  } else {
+    throw new Error(`Provided plugin is not an instance of Plugin`);
   }
-  /**
-   * @param {string} message - Message to display
-   * @param {Function} fct - The function to execute
-   * @returns {Promise<void>}
-   * @description
-   * Wait function: display loading during 'fct' execution
-   * @example
-   * const { wait } = require('@hperchec/juisy').utils
-   * await wait('Waiting', async () => {
-   *   // Do async logic
-   * })
-   */
-  static async wait(message, fct) {
-    loading.display(message);
-    await fct();
-    loading.stop();
+};
+CLIFactory.removePlugin = function(name) {
+  const index = registeredPlugins.findIndex((rp) => rp.name === name);
+  if (index > -1) {
+    registeredPlugins.splice(index, 1);
+  } else {
+    throw new Error(`CLI plugin "${name}" is not registered`);
   }
-  /**
-   * See `strip-ansi` package documentation
-   * @see https://www.npmjs.com/package/strip-ansi
-   */
-  static stripAnsi = _stripAnsi;
-}
+};
+CLIFactory.getRegisteredPlugins = function() {
+  return [...registeredPlugins];
+};
 
 const { log, $style } = OutputUtils;
 class InterfaceUtils {
   /**
    * Get root directory path
    * @example
-   * import { CLIUtils: { rootDir } } from '@hperchec/juisy'
+   * const { rootDir } = InterfaceUtils
    * console.log(rootDir) // => 'path/to/your/root/dir'
    */
   static rootDir = process.cwd();
-  /**
-   * @param {string} bin - Command
-   * @param {string[]} args - Same as execa second arg
-   * @param {object} [opts] - Options
-   * @returns {Promise<object>} The `execa` Promise
-   * @throws {RunError}
-   * @description
-   * Run command (child_process). See also `execa` package documentation
-   * @example
-   * const { run } = require('@hperchec/juisy').utils
-   * await run('npm', [ 'run', 'test' ], { stdio: 'inherit' })
-   */
-  static run(bin, args, opts = {}) {
-    return execa(bin, args, { stdio: "inherit", cwd: InterfaceUtils.rootDir, ...opts });
+  static run(bin, args, opts) {
+    let execaOptions = {
+      stdio: "inherit",
+      cwd: InterfaceUtils.rootDir
+    };
+    let callExeca = () => execa`${bin}`;
+    if (args) {
+      if (args instanceof Array) {
+        execaOptions = {
+          ...execaOptions,
+          ...opts || {}
+        };
+        callExeca = () => execa(bin, args, execaOptions);
+      } else if (typeof args === "object") {
+        execaOptions = {
+          ...execaOptions,
+          ...args
+        };
+        callExeca = () => execa(execaOptions)`${bin}`;
+      } else {
+        throw new Error("Second argument must be either an array of arguments or an object of options");
+      }
+    }
+    return callExeca();
   }
   /**
-   * @alias utils.abort
    * @param {number} [code] - Code for process.exit() (default: 0)
    * @returns {void}
    * @description
    * Exit process
    * @example
-   * const { abort } = require('@hperchec/juisy').utils
+   * const { abort } = InterfaceUtils
    * abort() // => exit process with code 0
    * abort(1) // => error code
    */
@@ -565,15 +635,15 @@ class InterfaceUtils {
     process.exit(code);
   }
   /**
-   * @alias utils.confirm
-   * @param {prompts.PromptObject} question - A prompt question object (see https://gitlab.com/hperchec/juisy/-/blob/main/documentation/utils.md#utilspromptsargs-object)
+   * @param question - A prompt question object
+   * @param options - A prompt options object
    * @returns {Promise<boolean>} - True if confirmed
    * @description
    * Demand confirmation with prompts native util. If not confirmed, it will automatically abort the script.
    * @example
    * confirm({ message: 'Confirm to continue' }) // Deny it will abort the script
    */
-  static async confirm(question) {
+  static async confirm(question, options = {}) {
     if (!question) {
       question = {
         type: "confirm",
@@ -588,7 +658,7 @@ class InterfaceUtils {
         type: "confirm",
         name: "yes"
       }
-    ]);
+    ], options);
     if (!yes) {
       InterfaceUtils.abort();
     } else {
@@ -618,79 +688,90 @@ const LoadEnvFile = new Plugin("built-in:load-env-file", {
   }
 });
 
-const bumpVersion = new Command({
-  command: "bump-version",
-  describe: "Bump version in package.json file",
-  meta: {
+class BumpVersionCommand extends Command {
+  command = "bump-version [targetVersion]";
+  describe = "Bump version in package.json file";
+  meta = {
     private: true
-  },
-  builder: function(cli) {
+  };
+  builder(cli) {
+    cli.positional("targetVersion", {
+      describe: "The target version to set manually",
+      type: "string"
+    });
     cli.option("p", {
       alias: "preid",
       type: "string",
       describe: "Pre-release id",
       requiresArg: true
     });
+    cli.option("f", {
+      alias: "file",
+      type: "string",
+      describe: "Path to package.json file",
+      requiresArg: true
+    });
+    cli.option("indent", {
+      type: "number",
+      describe: "Number of indent spaces used by JSON.stringify. Default: 2",
+      default: 2,
+      requiresArg: true
+    });
     return cli;
-  },
+  }
   async handler(argv) {
     const { $style, step, substep, error } = OutputUtils;
-    const { run, prompts, abort } = InterfaceUtils;
-    const packageJson = getPackageInfo();
-    let targetVersion;
-    const currentVersion = packageJson.version;
-    packageJson.name;
-    const preId = argv.preid || semver.prerelease(currentVersion) && semver.prerelease(currentVersion)[0];
-    const inc = (i) => semver.inc(currentVersion, i, preId);
-    const versionIncrements = [
-      "patch",
-      "minor",
-      "major",
-      ...preId ? ["prepatch", "preminor", "premajor", "prerelease"] : []
-    ];
+    const { confirm, prompts, abort } = InterfaceUtils;
+    const packageJsonPath = argv.file ? path.isAbsolute(argv.file) ? argv.file : path.join(process.cwd(), argv.file) : path.resolve(process.cwd(), "package.json");
+    const pkg = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8"));
+    let targetVersion = argv.targetVersion;
     step("Bump version");
-    const { release } = await prompts([
-      {
-        type: "select",
-        name: "release",
-        message: "Release type:",
-        choices: versionIncrements.map((i) => ({ title: `${i} (${inc(i)})`, value: inc(i) })).concat([{ title: "custom", value: "custom" }])
-      }
-    ]);
-    if (release === "custom") {
-      const { version: customVersion } = await prompts([
+    if (!targetVersion) {
+      const currentVersion = pkg.version;
+      pkg.name;
+      const preId = argv.preid || semver.prerelease(currentVersion) && semver.prerelease(currentVersion)[0];
+      const inc = (i) => semver.inc(currentVersion, i, preId);
+      const versionIncrements = [
+        "patch",
+        "minor",
+        "major",
+        ...preId ? ["prepatch", "preminor", "premajor", "prerelease"] : []
+      ];
+      const { release } = await prompts([
         {
-          type: "text",
-          name: "version",
-          message: "New custom version:",
-          initial: currentVersion,
-          validate: (value) => Boolean(semver.valid(value))
+          type: "select",
+          name: "release",
+          message: "Release type:",
+          choices: versionIncrements.map((i) => ({ title: `${i} (${inc(i)})`, value: inc(i) })).concat([{ title: "custom", value: "custom" }])
         }
-      ]);
-      targetVersion = customVersion;
-    } else {
-      targetVersion = release;
-    }
-    const { yes } = await prompts([
-      {
+      ], { onCancel: () => abort() });
+      if (release === "custom") {
+        const { version: customVersion } = await prompts([
+          {
+            type: "text",
+            name: "version",
+            message: "New custom version:",
+            initial: currentVersion,
+            validate: (value) => Boolean(semver.valid(value))
+          }
+        ], { onCancel: () => abort() });
+        targetVersion = customVersion;
+      } else {
+        targetVersion = release;
+      }
+      await confirm({
         type: "confirm",
         name: "yes",
         message: `Releasing v${targetVersion}. Confirm?`,
         initial: true
-      }
-    ]);
-    if (!yes) {
-      abort();
-      return;
+      }, {
+        onCancel: () => abort()
+      });
     }
-    this.log();
     let commandError = false;
     try {
-      await run("npm", [
-        "--no-git-tag-version",
-        "version",
-        targetVersion
-      ], { stdio: "inherit" });
+      pkg.version = targetVersion;
+      fs$1.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, argv.indent) + "\n");
     } catch (e) {
       commandError = e;
     }
@@ -699,17 +780,18 @@ const bumpVersion = new Command({
       error("An error has occured.", commandError);
       abort(1);
     } else {
-      substep($style.green("✔ Version successfuly bumped"), { last: true });
+      substep($style.green("✔ Version successfuly bumped"));
+      substep($style.cyan("New version: " + targetVersion), { last: true });
       this.log();
     }
   }
-});
+}
 
 const RegisterBumpVersionCommand = new Plugin("built-in:register-bump-version-command", {
   beforeCreate({ defineDefaultCommand, defineSettings, builder, factoryOptions }) {
     defineDefaultCommand({
       fullSignature: "bump-version",
-      commandObject: bumpVersion,
+      commandObject: new BumpVersionCommand(),
       children: []
     });
   }
@@ -1299,6 +1381,9 @@ const RegisterLintCommands = new Plugin("built-in:register-lint-commands", {
 const release = new Command({
   command: "release",
   describe: "Make a release",
+  meta: {
+    private: true
+  },
   builder(cli) {
     cli.option("d", {
       alias: "dry-run",
@@ -1310,6 +1395,9 @@ const release = new Command({
       describe: 'Increment "major", "minor", "patch", or "pre*" version; or specify version',
       default: "patch",
       requiresArg: true
+    }).option("preRelease", {
+      type: "string",
+      describe: "Same as release-it --preRelease option. See: https://github.com/release-it/release-it/blob/main/docs/pre-releases.md"
     }).option("ci", {
       type: "boolean",
       describe: "No prompts, no user interaction; activated automatically in CI environments"
@@ -1406,6 +1494,10 @@ const release = new Command({
         releaseItCmdArgs.push(argv.increment);
       }
     }
+    if (argv.preRelease !== void 0) {
+      releaseItCmdArgs.push("--preRelease");
+      releaseItCmdArgs.push(argv.preRelease);
+    }
     if (argv.ci) {
       releaseItCmdArgs.push("--ci");
     }
@@ -1469,6 +1561,9 @@ const RegisterReleaseCommand = new Plugin("built-in:register-release-command", {
 const test = new Command({
   command: "test",
   describe: "Run tests",
+  meta: {
+    private: true
+  },
   async handler(argv) {
     const { $style } = OutputUtils;
     this.log($style.yellow("Command not implemented. Read the doc and build your own!"));
@@ -1492,32 +1587,15 @@ function wrapCommandBuilder(target, builder) {
     return _target(builder(cli));
   };
 }
-function wrapCommandhandler(target, handler) {
-  return function(args) {
-    handler.call(this, args);
-    return target.call(this, args);
-  };
-}
 
-const visitor$3 = function(commandObject, cli) {
+const visitor$2 = function(commandObject, cli) {
   const defaultCommand = getDefaultCommand(commandObject.command);
   if (defaultCommand) {
     commandObject.builder = wrapCommandBuilder(commandObject.builder, function(_cli) {
       if (defaultCommand.children?.length) {
         for (const child of defaultCommand.children) {
           if (cli.hasDefaultCommand(child.fullSignature)) {
-            cli.command({
-              // @ts-ignore
-              aliases: child.commandObject.aliases,
-              command: child.commandObject.command,
-              describe: child.commandObject.describe,
-              builder: (__cli) => {
-                return child.commandObject.builder(__cli);
-              },
-              handler: child.commandObject.handler,
-              meta: child.commandObject.meta,
-              middlewares: child.commandObject.middlewares
-            });
+            cli.command(child.commandObject.toObject());
           }
         }
       }
@@ -1526,39 +1604,11 @@ const visitor$3 = function(commandObject, cli) {
   }
   return commandObject;
 };
-const options$3 = {};
-
-const DefaultCommandFallbacks = new Plugin("built-in:default-command-fallbacks", {
-  created({ engine, builder, factoryOptions }) {
-    engine.globalCommandVisitor("default-command-fallbacks-visitor", visitor$3, options$3);
-  }
-});
-
-const visitor$2 = function(commandObject, cli) {
-  commandObject.handler = wrapCommandhandler(commandObject.handler, function(args) {
-    Object.defineProperty(this, "engine", {
-      get() {
-        return cli;
-      }
-    });
-    Object.defineProperty(this, "log", {
-      get() {
-        return (msg, options2 = {}) => {
-          OutputUtils.log(msg, {
-            ...options2,
-            loggerInstance: cli.getInternalMethods().getLoggerInstance()
-          });
-        };
-      }
-    });
-  });
-  return commandObject;
-};
 const options$2 = {};
 
-const CommandHandlerInjections = new Plugin("built-in:command-handler-injections", {
+const DefaultCommandFallbacks = new Plugin("built-in:default-command-fallbacks", {
   created({ engine, builder, factoryOptions }) {
-    engine.globalCommandVisitor("command-handler-injections-visitor", visitor$2, options$2);
+    engine.globalCommandVisitor("default-command-fallbacks-visitor", visitor$2, options$2);
   }
 });
 
@@ -1674,8 +1724,7 @@ CLIFactory.use(RegisterLintCommands);
 CLIFactory.use(RegisterReleaseCommand);
 CLIFactory.use(RegisterTestCommand);
 CLIFactory.use(DefaultCommandFallbacks);
-CLIFactory.use(CommandHandlerInjections);
 CLIFactory.use(CommandMeta);
 CLIFactory.use(PrivateCommands);
 
-export { CLIFactory, Command, InterfaceUtils, OutputUtils, extractUsage };
+export { CLIFactory, Command, InterfaceUtils, OutputUtils, Plugin, extractUsage };