juisy 2.0.0-beta.0 → 2.0.0-beta.8

package/dist/cli/index.js

@@ -1,21 +1,312 @@
 /*!
- * juisy v1.4.0
+ * juisy v2.0.0-beta.8
  * Copyright © 2022-Present Hervé Perchec
  */
 
 import { hideBin } from 'yargs/helpers';
-import execa from 'execa';
+import deepmerge from 'deepmerge';
+import { pathToFileURL } from 'node:url';
+import fs from 'fs-extra';
+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 Yargs from 'yargs/yargs';
-import deepmerge from 'deepmerge';
+import dotenv from '@dotenvx/dotenvx';
+import semver from 'semver';
+import { getPackageInfo } from 'juisy';
+import kebabcase from 'lodash.kebabcase';
+import { ReadmeTemplater } from 'juisy/templater';
+import path from 'node:path';
+import { ESLint } from 'eslint';
+import fs$1 from 'node:fs';
+import yargsParser from 'yargs-parser';
+
+class Plugin {
+  constructor(name, pluginObject) {
+    this.name = name;
+    if (pluginObject.beforeCreate) {
+      this.beforeCreate = pluginObject.beforeCreate;
+    } else {
+      this.beforeCreate = () => {
+      };
+    }
+    if (pluginObject.created) {
+      this.created = pluginObject.created;
+    } else {
+      this.created = () => {
+      };
+    }
+  }
+  /**
+   * The plugin unique name
+   */
+  name;
+  /**
+   * The beforeCreate hook (can be async)
+   */
+  beforeCreate;
+  /**
+   * The created hook (must be sync)
+   */
+  created;
+}
+
+function createEngine(yargs) {
+  const xargs = yargs;
+  xargs._isPrivate = false;
+  xargs._globalCommandVisitors = {};
+  xargs._globalCommandVisitorsEnabled = /* @__PURE__ */ new Set([]);
+  xargs._disabledDefaultCommands = /* @__PURE__ */ new Set([]);
+  xargs._meta = {
+    private: false
+  };
+  xargs._settings = {};
+  const originalCommandMethod = xargs.command;
+  xargs.originalCommand = originalCommandMethod;
+  xargs.command = command;
+  xargs.disableDefaultCommand = disableDefaultCommand;
+  xargs.hasDefaultCommand = hasDefaultCommand;
+  xargs.globalCommandVisitor = globalCommandVisitor;
+  xargs.globalCommandVisitorOptions = globalCommandVisitorOptions;
+  xargs.hasGlobalCommandVisitor = hasGlobalCommandVisitor;
+  xargs.disableGlobalCommandVisitors = disableGlobalCommandVisitors;
+  xargs.enableGlobalCommandVisitors = enableGlobalCommandVisitors;
+  xargs.isPrivate = isPrivate;
+  xargs.getSettings = getSettings;
+  return xargs.strict().help();
+}
+function command(...args) {
+  const self = this;
+  if (args.length === 1) {
+    const visit = (cmdModule) => {
+      const cmdObj = {
+        ...cmdModule
+      };
+      let failOnFalsyReturn;
+      for (const name of self._globalCommandVisitorsEnabled) {
+        const globalVisitor = self._globalCommandVisitors[name];
+        if (!globalVisitor(cmdObj, self, globalVisitor.options)) {
+          failOnFalsyReturn = true;
+        }
+      }
+      return failOnFalsyReturn ? false : cmdObj;
+    };
+    if (args[0] instanceof Array) {
+      const cmdsArray = [];
+      for (const commandModule of args[0]) {
+        const visited = visit(commandModule);
+        if (visited)
+          cmdsArray.push(visited);
+      }
+      return self.originalCommand(cmdsArray);
+    } else {
+      const visited = visit(args[0]);
+      return visited ? self.originalCommand(visited) : self;
+    }
+  } else {
+    return self.originalCommand(...args);
+  }
+}
+function disableDefaultCommand(signature) {
+  if (getDefaultCommand(signature)) {
+    this._disabledDefaultCommands.add(signature);
+  } else {
+    throw new Error('Default command: "' + signature + '" does not exist.');
+  }
+  return this;
+}
+function hasDefaultCommand(signature) {
+  return !this._disabledDefaultCommands.has(signature);
+}
+function globalCommandVisitor(name, visitor, defaultOptions = {}) {
+  this._globalCommandVisitors[name] = visitor;
+  return this.enableGlobalCommandVisitors([name]).globalCommandVisitorOptions(name, defaultOptions);
+}
+function globalCommandVisitorOptions(name, options) {
+  this._globalCommandVisitors[name].options = {
+    ...this._globalCommandVisitors[name].options,
+    ...options
+  };
+  return this;
+}
+function hasGlobalCommandVisitor(name) {
+  return Object.keys(this._globalCommandVisitors).includes(name);
+}
+function disableGlobalCommandVisitors(visitors = []) {
+  for (const name of visitors) {
+    if (this.hasGlobalCommandVisitor(name)) {
+      this._globalCommandVisitorsEnabled.delete(name);
+    } else {
+      throw new Error('Global command visitor: "' + name + '" not defined.');
+    }
+  }
+  return this;
+}
+function enableGlobalCommandVisitors(visitors = []) {
+  for (const name of visitors) {
+    if (this.hasGlobalCommandVisitor(name)) {
+      this._globalCommandVisitorsEnabled.add(name);
+    } else {
+      throw new Error('Global command visitor: "' + name + '" not defined.');
+    }
+  }
+  return this;
+}
+function isPrivate() {
+  return this._isPrivate;
+}
+function getSettings(path) {
+  return path ? lodashGet(this._settings, path) : this._settings;
+}
+
+const proxify = (target) => {
+  const tmp = new Proxy(target instanceof Array ? [] : {}, {
+    // Overwrite Object type getter to 'observe'
+    get: (obj, prop) => {
+      if (prop in obj) {
+        if (resolveSettingsCallbacks[prop]) {
+          return resolveSettingsCallbacks[prop](obj[prop]);
+        }
+        return obj[prop];
+      }
+      return undefined;
+    }
+  });
+  for (const property in target) {
+    tmp[property] = target[property];
+  }
+  return tmp;
+};
+const defaultGlobalSettings = {
+  // ...
+};
+const defaultCommands = [];
+const registeredPlugins = [];
+function defineDefaultCommand(command) {
+  defaultCommands.push(command);
+}
+const findCommandIn = (fullSignature, commands) => {
+  for (const command of commands) {
+    if (command.fullSignature === fullSignature) {
+      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 (CommandModule)
-   * @param {CommandModule} commandObject - The command definition object
+   * Creates a Command instance from object (CommandObject)
+   * @param {CommandObject} commandObject - The command definition object
    */
   constructor(commandObject) {
     this.command = commandObject.command;
@@ -25,6 +316,7 @@ class Command {
     this.meta = commandObject.meta;
     this.builder = commandObject.builder || ((cli) => cli);
     this.handler = commandObject.handler;
+    this.middlewares = commandObject.middlewares;
   }
   /**
    * The command
@@ -53,7 +345,12 @@ class Command {
   /**
    * Command handler
    */
+  // @ts-ignore
   handler;
+  /**
+   * Command middlewares
+   */
+  middlewares;
 }
 
 const loading = {
@@ -115,7 +412,7 @@ class OutputUtils {
   static formatOutputMessage(msg, options = {}) {
     let formatted = `${msg}`;
     if (options.indentChar) {
-      if (options.indent === void 0) {
+      if (options.indent === undefined) {
         options.indent = 1;
       }
     } else {
@@ -160,7 +457,7 @@ class OutputUtils {
   }
   /**
    * @param msg - The message to display
-   * @param {Error} [err] - If provided, throw the error
+   * @param err - If provided, throw the error
    * @description
    * Display error message. Throws `err` if provided.
    * @example
@@ -168,9 +465,9 @@ class OutputUtils {
    * error('No configuration file') // => '[31m⨉ ERROR: No configuration file[0m'
    * error('No configuration file', error) // => Log and throws error
    */
-  static error(msg, err = void 0) {
+  static error(msg, err) {
     OutputUtils.log(OutputUtils.$style.red(`⨉ ERROR: ${msg}`));
-    if (err !== void 0) {
+    if (err !== undefined) {
       OutputUtils.log();
       throw err;
     }
@@ -186,7 +483,7 @@ class OutputUtils {
    */
   static step(msg, options = {}) {
     OutputUtils.stepsCache.index++;
-    if (options.index === void 0) {
+    if (options.index === undefined) {
       options.index = OutputUtils.stepsCache.index;
     }
     OutputUtils.log(`${options.index !== null ? options.index + " - " : ""}${msg}`, { indentChar: "● " });
@@ -242,6 +539,7 @@ class InterfaceUtils {
    * @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
@@ -307,6 +605,888 @@ class InterfaceUtils {
   static prompts = _prompts;
 }
 
+const LoadEnvFile = new Plugin("built-in:load-env-file", {
+  beforeCreate({ defineDefaultCommand, defineSettings, builder, factoryOptions }) {
+    if (factoryOptions.loadEnv !== false) {
+      dotenv.config({
+        // Default to not verbose, can be overridden
+        debug: false,
+        verbose: false,
+        quiet: true
+      });
+    }
+  }
+});
+
+const bumpVersion = new Command({
+  command: "bump-version",
+  describe: "Bump version in package.json file",
+  meta: {
+    private: true
+  },
+  builder: function(cli) {
+    cli.option("p", {
+      alias: "preid",
+      type: "string",
+      describe: "Pre-release id",
+      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"] : []
+    ];
+    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([
+        {
+          type: "text",
+          name: "version",
+          message: "New custom version:",
+          initial: currentVersion,
+          validate: (value) => Boolean(semver.valid(value))
+        }
+      ]);
+      targetVersion = customVersion;
+    } else {
+      targetVersion = release;
+    }
+    const { yes } = await prompts([
+      {
+        type: "confirm",
+        name: "yes",
+        message: `Releasing v${targetVersion}. Confirm?`,
+        initial: true
+      }
+    ]);
+    if (!yes) {
+      abort();
+      return;
+    }
+    this.log();
+    let commandError = false;
+    try {
+      await run("npm", [
+        "--no-git-tag-version",
+        "version",
+        targetVersion
+      ], { stdio: "inherit" });
+    } catch (e) {
+      commandError = e;
+    }
+    if (commandError) {
+      substep($style.red("❌ An error has occured."), { last: true });
+      error("An error has occured.", commandError);
+      abort(1);
+    } else {
+      substep($style.green("✔ Version successfuly bumped"), { 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,
+      children: []
+    });
+  }
+});
+
+const changelog = new Command({
+  command: "changelog",
+  describe: "Generate CHANGELOG file",
+  meta: {
+    private: true
+  },
+  builder: function(cli) {
+    return cli;
+  },
+  async handler(argv) {
+    const { $style, step, substep, error, wait } = OutputUtils;
+    const { run } = InterfaceUtils;
+    step("Generating changelog");
+    const { onReleaseConfig, ...commandOptions } = this.engine.getSettings("changelog");
+    const flattenOptions = (options) => {
+      const _array = [];
+      for (const key in options) {
+        if (typeof options[key] === "boolean") {
+          _array.push("--" + kebabcase(key));
+        } else {
+          _array.push("--" + kebabcase(key));
+          _array.push(String(options[key]));
+        }
+      }
+      return _array;
+    };
+    await wait("Generating", async () => {
+      try {
+        await run("npx", [
+          "conventional-changelog",
+          ...flattenOptions(commandOptions)
+        ], { stdio: "inherit" });
+      } catch (e) {
+        error("Unable to generate changelog", e);
+      }
+    });
+    substep($style.green("✔ Success"), { last: true });
+    this.log();
+  }
+});
+
+const RegisterChangelogCommand = new Plugin("built-in:register-changelog-command", {
+  beforeCreate({ defineDefaultCommand, defineSettings, builder, factoryOptions }) {
+    defineSettings("changelog", {
+      infile: "CHANGELOG.md",
+      preset: "angular",
+      sameFile: true,
+      onReleaseConfig: {}
+    });
+    defineDefaultCommand({
+      fullSignature: "changelog",
+      commandObject: changelog,
+      children: []
+    });
+  }
+});
+
+const docs = new Command({
+  command: "docs <command>",
+  describe: "Manage project documentation",
+  meta: {
+    private: true
+  },
+  builder(cli) {
+    return cli.demandCommand(1, "Command is missing. See help to learn more.");
+  },
+  handler(argv) {
+  }
+});
+
+const docsGenerateAPI = new Command({
+  command: "generate:api",
+  describe: "Generate API docs from source code",
+  async handler(argv) {
+    const { $style } = OutputUtils;
+    this.log($style.yellow("Command not implemented. Read the doc and build your own!"));
+    this.log();
+  }
+});
+
+const docsGenerateCLI = new Command({
+  command: "generate:cli",
+  describe: "Generate CLI docs",
+  builder(cli) {
+    cli.option("config", {
+      alias: "c",
+      describe: "Path to config file",
+      type: "string",
+      default: "./docs/cli/config.js"
+    });
+    cli.config(cli.getSettings("docs.cli"));
+    return cli;
+  },
+  async handler(argv) {
+    const templater = new ReadmeTemplater(argv.config);
+    await templater.generate();
+  }
+});
+
+const docsGenerateReadme = new Command({
+  command: "generate:readme",
+  describe: "Generate README.md",
+  builder(cli) {
+    cli.option("config", {
+      alias: "c",
+      describe: "Path to config file",
+      type: "string",
+      default: "./docs/readme/config.js"
+    });
+    cli.config(cli.getSettings("docs.readme"));
+    return cli;
+  },
+  async handler(argv) {
+    const templater = new ReadmeTemplater(argv.config);
+    await templater.generate();
+  }
+});
+
+const RegisterDocsCommands = new Plugin("built-in:register-docs-commands", {
+  beforeCreate({ defineDefaultCommand, defineSettings, builder, factoryOptions }) {
+    defineSettings("docs", {
+      readme: {
+        config: "./docs/readme/config.js"
+      },
+      cli: {
+        config: "./docs/cli/config.js"
+      }
+    });
+    defineDefaultCommand({
+      fullSignature: "docs <command>",
+      commandObject: docs,
+      children: [
+        {
+          fullSignature: "docs generate:api",
+          commandObject: docsGenerateAPI
+        },
+        {
+          fullSignature: "docs generate:cli",
+          commandObject: docsGenerateCLI
+        },
+        {
+          fullSignature: "docs generate:readme",
+          commandObject: docsGenerateReadme
+        }
+      ]
+    });
+  }
+});
+
+const gitHooks = new Command({
+  command: "git-hooks <command>",
+  describe: "Git relative commands",
+  meta: {
+    private: true
+  },
+  builder: function(cli) {
+    return cli.demandCommand(1, "Command is missing. See help to learn more.");
+  },
+  handler: async function(argv) {
+  }
+});
+
+const gitHooksSync = new Command({
+  command: "sync",
+  describe: "Sync git hooks",
+  builder(cli) {
+    return cli;
+  },
+  async handler(argv) {
+    const { $style, error, step, substep } = OutputUtils;
+    const { run, abort } = InterfaceUtils;
+    step("Sync git hooks");
+    const gitHooksConfig = getPackageInfo()["simple-git-hooks"] || this.engine.getSettings("gitHooks");
+    const tempConfigFilePath = "./__TEMP_SIMPLE_GIT_HOOKS_CONFIG__.json";
+    fs.writeFileSync(path.resolve(tempConfigFilePath), JSON.stringify(gitHooksConfig));
+    let commandError = false;
+    try {
+      await run("npx", [
+        "simple-git-hooks",
+        tempConfigFilePath
+      ], { stdio: "pipe" });
+    } catch (e) {
+      commandError = e;
+    }
+    fs.unlinkSync(path.resolve(tempConfigFilePath));
+    if (commandError) {
+      substep($style.red("❌ Unable to sync git hooks."), { last: true });
+      error("Unable to sync git hooks.", commandError);
+      abort(1);
+    } else {
+      substep($style.green("✔ Git hooks successfuly sync"), { last: true });
+      this.log();
+    }
+  }
+});
+
+const gitHooksReset = new Command({
+  command: "reset",
+  describe: "Reset git hooks",
+  builder(cli) {
+    return cli;
+  },
+  async handler(argv) {
+    const { $style, step, substep } = OutputUtils;
+    const { rootDir, run, abort } = InterfaceUtils;
+    step("Reset git hooks");
+    const tempConfigFilePath = "./__TEMP_SIMPLE_GIT_HOOKS_CONFIG__.json";
+    fs.writeFileSync(path.resolve(rootDir, tempConfigFilePath), "{}");
+    let commandError = false;
+    try {
+      await run("npx", [
+        "simple-git-hooks",
+        tempConfigFilePath
+      ], { stdio: "pipe" });
+    } catch (e) {
+      commandError = e;
+    }
+    fs.unlinkSync(path.resolve(rootDir, tempConfigFilePath));
+    if (commandError) {
+      substep($style.red("❌ Unable to reset git hooks."), { last: true });
+      abort(1);
+    } else {
+      substep($style.green("✔ Git hooks successfuly reset"), { last: true });
+      this.log();
+    }
+  }
+});
+
+const RegisterGitHooksCommands = new Plugin("built-in:register-git-hooks-commands", {
+  beforeCreate({ defineDefaultCommand, defineSettings, builder, factoryOptions }) {
+    defineSettings("gitHooks", {
+      "pre-commit": "node ./bin/scripts/pre-commit.js",
+      "commit-msg": "node ./bin/scripts/commit-msg.js ${1}"
+    });
+    defineDefaultCommand({
+      fullSignature: "git-hooks <command>",
+      commandObject: gitHooks,
+      children: [
+        {
+          fullSignature: "git-hooks reset",
+          commandObject: gitHooksReset
+        },
+        {
+          fullSignature: "git-hooks sync",
+          commandObject: gitHooksSync
+        }
+      ]
+    });
+  }
+});
+
+function resolveESLintSettings(settings = []) {
+  return settings;
+}
+function resolveCommitlintSettings(settings = {}) {
+  return settings;
+}
+function resolveMarkdownlintSettings(settings = []) {
+  const normalizeRootConfig = (config = {}) => {
+    return {
+      config: {},
+      ...config
+    };
+  };
+  const normalizeConfig = (config = {}) => {
+    return {
+      config: {},
+      ...config,
+      globs: config.globs
+    };
+  };
+  let resolved = [];
+  let rootConfig = {
+    config: {}
+  };
+  const globScopedConfigs = [];
+  for (const item of settings) {
+    if (!item.globs && typeof rootConfig.config !== "string") {
+      rootConfig = deepmerge(rootConfig, item);
+    } else if (!(item.globs instanceof Array) || !item.globs.length) {
+      throw new Error('lint.markdown configuration: if provided, "globs" property must be a non-empty array');
+    } else {
+      globScopedConfigs.push(item);
+    }
+  }
+  resolved.push(normalizeRootConfig(rootConfig));
+  resolved.push(...globScopedConfigs.map(normalizeConfig));
+  return resolved;
+}
+function resolveLintStagedSettings(settings = {}) {
+  return settings;
+}
+function resolveSettings(settings = {}) {
+  const resolved = {
+    default: resolveESLintSettings(settings.default),
+    commit: resolveCommitlintSettings(settings.commit),
+    markdown: resolveMarkdownlintSettings(settings.markdown),
+    staged: resolveLintStagedSettings(settings.staged)
+  };
+  return resolved;
+}
+
+const lint = new Command({
+  command: "lint [files]",
+  describe: "Lint source code",
+  meta: {
+    private: true
+  },
+  builder(cli) {
+    cli.strict(false).option("fix", {
+      alias: "f",
+      describe: "Automatically fix problems",
+      type: "boolean",
+      default: false
+    }).option("config", {
+      alias: "c",
+      describe: "Provide configuration file path",
+      type: "string",
+      requiresArg: true
+    });
+    const lintSettings = cli.getSettings("lint.default");
+    if (lintSettings?.config) {
+      cli.config(lintSettings);
+    }
+    return cli;
+  },
+  async handler(argv) {
+    const { step } = OutputUtils;
+    step("Configuring linter");
+    const lintSettings = this.engine.getSettings("lint.default") || {};
+    const eslintOptions = {
+      fix: !!argv.fix
+    };
+    if (argv.config) {
+      eslintOptions.overrideConfigFile = argv.config;
+    } else {
+      eslintOptions.baseConfig = lintSettings;
+    }
+    const eslint = new ESLint(eslintOptions);
+    step("Linting files");
+    const results = await eslint.lintFiles([argv.files || "."]);
+    if (argv.fix) {
+      step("Fix problems");
+      await ESLint.outputFixes(results);
+    }
+    const formatter = await eslint.loadFormatter("stylish");
+    const resultText = formatter.format(results);
+    console.log(resultText);
+    this.log();
+  }
+});
+
+const lintCommit = new Command({
+  command: "lint:commit [input]",
+  describe: "Lint commit message with commitlint. Accepts all options of native commitlint. See also https://github.com/conventional-changelog/commitlint",
+  meta: {
+    private: true
+  },
+  builder(cli) {
+    cli.strict(false).option("config", {
+      // No alias because -c is already used by commitlint cli
+      describe: "Provide configuration file path",
+      type: "string",
+      requiresArg: true
+    });
+    const lintSettings = cli.getSettings("lint.commit");
+    if (lintSettings?.config) {
+      cli.config(lintSettings);
+    }
+    return cli;
+  },
+  async handler(argv) {
+    const { abort, run } = InterfaceUtils;
+    const { $style, step, substep, error } = OutputUtils;
+    step("Configuring commitlint");
+    const lintSettings = this.engine.getSettings("lint.commit");
+    const commitLintCmdArgs = yargsParser([...process.argv].slice(3), {
+      configuration: {
+        "halt-at-non-option": true,
+        "unknown-options-as-args": true
+      }
+    })._.map(String);
+    const tempConfigFilePath = "./__TEMP_COMMITLINT_CONFIG__.json";
+    let tempConfig;
+    if (!commitLintCmdArgs.includes("--config") && !commitLintCmdArgs.includes("-g")) {
+      if (argv.config) {
+        commitLintCmdArgs.push("--config", argv.config);
+      } else {
+        if (lintSettings) {
+          tempConfig = lintSettings;
+          commitLintCmdArgs.push("--config", tempConfigFilePath);
+          fs$1.writeFileSync(path.resolve(tempConfigFilePath), JSON.stringify(tempConfig));
+        }
+      }
+    }
+    let commandError;
+    try {
+      await run("npx", ["commitlint", ...commitLintCmdArgs], { stdio: "pipe" });
+    } catch (e) {
+      commandError = e;
+    }
+    if (tempConfig) {
+      fs$1.unlinkSync(path.resolve(tempConfigFilePath));
+    }
+    if (commandError) {
+      substep($style.red("❌ An error has occured."), { last: true });
+      error("An error has occured.", commandError);
+    } else {
+      substep($style.green("✔ Commit successfuly linted"), { last: true });
+      this.log();
+    }
+  }
+});
+
+const lintMarkdown = new Command({
+  command: "lint:markdown",
+  describe: "Lint markdown files with markdownlint-cli2. See also https://github.com/DavidAnson/markdownlint-cli2",
+  meta: {
+    private: true
+  },
+  builder(cli) {
+    cli.strict(false).option("fix", {
+      alias: "f",
+      describe: "Fix the problems",
+      type: "boolean"
+    });
+    return cli;
+  },
+  async handler(argv) {
+    const { abort, run } = InterfaceUtils;
+    const { $style, step, substep, error } = OutputUtils;
+    step("Configuring markdownlint");
+    const configs = this.engine.getSettings("lint.markdown") || [];
+    const rootConfig = configs.splice(configs.findIndex((config) => !config.globs), 1);
+    let commandError;
+    for (const item of configs) {
+      let tempConfig;
+      const mdLintCmdArgs = [...item.globs];
+      const tempConfigFilePath = "__TEMP_MARKDOWNLINT_CONFIG__.markdownlint-cli2.jsonc";
+      if (!item.config) {
+        tempConfig = rootConfig;
+      } else {
+        tempConfig = item.config;
+      }
+      if (typeof tempConfig === "string") {
+        mdLintCmdArgs.push("--config", tempConfig);
+      } else {
+        mdLintCmdArgs.push("--config", tempConfigFilePath);
+        fs$1.writeFileSync(path.resolve(tempConfigFilePath), JSON.stringify(tempConfig));
+      }
+      if (argv.fix) {
+        mdLintCmdArgs.push("--fix");
+      }
+      try {
+        await run("npx", ["markdownlint-cli2", ...mdLintCmdArgs], { stdio: "pipe" });
+      } catch (e) {
+        commandError = e;
+        if (fs$1.existsSync(path.resolve(tempConfigFilePath))) {
+          fs$1.unlinkSync(path.resolve(tempConfigFilePath));
+        }
+        break;
+      }
+    }
+    if (commandError) {
+      substep($style.red("❌ An error has occured."), { last: true });
+      if (commandError.stderr) {
+        console.error(commandError.stderr);
+      } else {
+        error("An error has occured.", commandError);
+      }
+    } else {
+      substep($style.green("✔ Markdown files successfuly linted"), { last: true });
+      this.log();
+    }
+  }
+});
+
+const lintStaged = new Command({
+  command: "lint:staged",
+  describe: "Lint staged files with lint-staged. Accepts all options of native lint-staged command. See also https://github.com/okonet/lint-staged",
+  meta: {
+    private: true
+  },
+  builder(cli) {
+    cli.strict(false).option("config", {
+      alias: "c",
+      describe: "Provide configuration file path",
+      type: "string",
+      requiresArg: true
+    });
+    const lintSettings = cli.getSettings("lint.staged");
+    if (lintSettings?.config) {
+      cli.config(lintSettings);
+    }
+    return cli;
+  },
+  async handler(argv) {
+    const { abort, run } = InterfaceUtils;
+    const { $style, step, substep, error } = OutputUtils;
+    step("Configuring lint-staged");
+    const lintSettings = this.engine.getSettings("lint.staged");
+    const lintStagedCmdArgs = [
+      // Pass all native options to lint-staged command
+      ...argv._.map(String)
+    ];
+    const tempConfigFilePath = "./__TEMP_LINT_STAGED_CONFIG__.json";
+    let tempConfig;
+    if (argv.config) {
+      lintStagedCmdArgs.push("--config", argv.config);
+    } else {
+      if (lintSettings) {
+        tempConfig = lintSettings;
+        lintStagedCmdArgs.push("--config", tempConfigFilePath);
+        fs$1.writeFileSync(path.resolve(tempConfigFilePath), JSON.stringify(tempConfig));
+      }
+    }
+    let commandError = false;
+    try {
+      await run("npx", [
+        "lint-staged",
+        ...lintStagedCmdArgs
+      ], { stdio: "inherit" });
+    } catch (e) {
+      commandError = e;
+    }
+    if (tempConfig) {
+      fs$1.unlinkSync(path.resolve(tempConfigFilePath));
+    }
+    if (commandError) {
+      substep($style.red("❌ An error has occured."), { last: true });
+      error("An error has occured.", commandError);
+      abort(1);
+    } else {
+      substep($style.green("✔ Files successfuly linted"), { last: true });
+      this.log();
+    }
+  }
+});
+
+const RegisterLintCommands = new Plugin("built-in:register-lint-commands", {
+  beforeCreate({ defineDefaultCommand, defineSettings, builder, factoryOptions }) {
+    defineSettings("lint", {
+      default: {
+        config: "eslint.config.js"
+      },
+      commit: {
+        extends: [
+          "@commitlint/config-conventional"
+        ]
+      },
+      markdown: [],
+      staged: {
+        "*.{js,cjs,ts}": [
+          "eslint --fix"
+        ]
+      }
+    }, {
+      resolve: resolveSettings
+    });
+    defineDefaultCommand({
+      fullSignature: "lint",
+      commandObject: lint,
+      children: []
+    });
+    defineDefaultCommand({
+      fullSignature: "lint:commit",
+      commandObject: lintCommit,
+      children: []
+    });
+    defineDefaultCommand({
+      fullSignature: "lint:markdown",
+      commandObject: lintMarkdown,
+      children: []
+    });
+    defineDefaultCommand({
+      fullSignature: "lint:staged",
+      commandObject: lintStaged,
+      children: []
+    });
+  }
+});
+
+const release = new Command({
+  command: "release",
+  describe: "Make a release",
+  builder(cli) {
+    cli.option("d", {
+      alias: "dry-run",
+      type: "boolean",
+      describe: "Do not touch or write anything, but show the commands"
+    }).option("i", {
+      alias: "increment",
+      type: "string",
+      describe: 'Increment "major", "minor", "patch", or "pre*" version; or specify version',
+      default: "patch",
+      requiresArg: true
+    }).option("ci", {
+      type: "boolean",
+      describe: "No prompts, no user interaction; activated automatically in CI environments"
+    }).option("only-version", {
+      type: "boolean",
+      describe: "Prompt only for version, no further interaction"
+    }).option("release-version", {
+      type: "boolean",
+      describe: "Print version number to be released"
+    }).option("changelog", {
+      type: "boolean",
+      describe: "Print changelog for the version to be released"
+    }).option("v", {
+      alias: "verbose",
+      type: "boolean",
+      describe: "Verbose output (user hooks output)"
+    }).option("V", {
+      alias: "extra-verbose",
+      type: "boolean",
+      describe: "Extra verbose output (also internal commands output)"
+    });
+    return cli;
+  },
+  async handler(argv) {
+    const { $style, step, substep, error, wait } = OutputUtils;
+    const { abort, run } = InterfaceUtils;
+    step("Prepare for release");
+    const tempConfigFilePath = "./__TEMP_RELEASE_IT_CONFIG__.json";
+    const releaseItCmdArgs = [];
+    let tempConfig;
+    let releaseItConfigFound = false;
+    substep($style.green("Resolving configuration"));
+    const releaseSettings = this.engine.getSettings("release");
+    if (getPackageInfo()["release-it"]) {
+      releaseItConfigFound = true;
+    } else {
+      const searchPlaces = [
+        ".release-it.json",
+        ".release-it.js",
+        ".release-it.ts",
+        ".release-it.cjs",
+        ".release-it.yaml",
+        ".release-it.yml",
+        ".release-it.toml"
+      ];
+      for (const fileName of searchPlaces) {
+        if (fs$1.existsSync(path.resolve(fileName))) {
+          releaseItConfigFound = true;
+          break;
+        }
+      }
+      if (!releaseItConfigFound) {
+        if (releaseSettings.config) {
+          if (typeof releaseSettings.config !== "string") {
+            error("release.config must be path to file as string");
+            abort(1);
+          }
+          releaseItCmdArgs.push("--config", releaseSettings.config);
+        } else {
+          const changelogSettings = this.engine.getSettings("changelog");
+          const { onReleaseConfig, preset, infile, context } = changelogSettings;
+          const releaseItChangelogConfig = {
+            infile: onReleaseConfig.infile || infile,
+            header: onReleaseConfig.header,
+            context: onReleaseConfig.context || (context ? JSON.parse(fs$1.readFileSync(path.resolve(context)).toString()) : {}),
+            preset: {
+              name: preset,
+              ...onReleaseConfig.preset || {}
+            },
+            tagOpts: onReleaseConfig.tagOpts,
+            commitsOpts: onReleaseConfig.commitsOpts,
+            whatBump: onReleaseConfig.whatBump,
+            ignoreRecommendedBump: onReleaseConfig.ignoreRecommendedBump,
+            strictSemVer: onReleaseConfig.strictSemVer
+          };
+          tempConfig = {
+            ...releaseSettings,
+            plugins: {
+              "@release-it/conventional-changelog": releaseItChangelogConfig
+            }
+          };
+          releaseItCmdArgs.push("--config", tempConfigFilePath);
+        }
+      }
+    }
+    if (argv["dry-run"]) {
+      releaseItCmdArgs.push("--dry-run");
+    }
+    if (argv.increment !== undefined) {
+      if (argv.increment === false) {
+        releaseItCmdArgs.push("--no-increment");
+      } else {
+        releaseItCmdArgs.push("--increment");
+        releaseItCmdArgs.push(argv.increment);
+      }
+    }
+    if (argv.ci) {
+      releaseItCmdArgs.push("--ci");
+    }
+    if (argv["only-version"]) {
+      releaseItCmdArgs.push("--only-version");
+    }
+    if (argv["release-version"]) {
+      releaseItCmdArgs.push("--release-version");
+    }
+    if (argv.changelog) {
+      releaseItCmdArgs.push("--changelog");
+    }
+    if (argv.verbose) {
+      releaseItCmdArgs.push("--verbose");
+    }
+    if (argv["extra-verbose"]) {
+      releaseItCmdArgs.push("-VV");
+    }
+    if (!releaseItConfigFound) {
+      fs$1.writeFileSync(path.resolve(tempConfigFilePath), JSON.stringify(tempConfig));
+    }
+    let commandError = false;
+    try {
+      await run("npx", [
+        "release-it",
+        ...releaseItCmdArgs
+      ], { stdio: "inherit" });
+    } catch (e) {
+      commandError = e;
+    }
+    if (!releaseItConfigFound) {
+      fs$1.unlinkSync(path.resolve(tempConfigFilePath));
+    }
+    if (commandError) {
+      substep($style.red("❌ Unable to release."), { last: true });
+      abort(1);
+    } else {
+      substep($style.green("✔ Release successfuly created"), { last: true });
+      this.log();
+    }
+  }
+});
+
+const RegisterReleaseCommand = new Plugin("built-in:register-release-command", {
+  beforeCreate({ defineDefaultCommand, defineSettings, builder, factoryOptions }) {
+    defineSettings("release", {
+      git: {
+        commitMessage: "chore(release): v${version}",
+        requireBranch: "main",
+        tagAnnotation: "v${version}"
+      }
+    });
+    defineDefaultCommand({
+      fullSignature: "release",
+      commandObject: release,
+      children: []
+    });
+  }
+});
+
+const test = new Command({
+  command: "test",
+  describe: "Run tests",
+  async handler(argv) {
+    const { $style } = OutputUtils;
+    this.log($style.yellow("Command not implemented. Read the doc and build your own!"));
+    this.log();
+  }
+});
+
+const RegisterTestCommand = new Plugin("built-in:register-test-command", {
+  beforeCreate({ defineDefaultCommand, defineSettings, builder, factoryOptions }) {
+    defineDefaultCommand({
+      fullSignature: "test",
+      commandObject: test,
+      children: []
+    });
+  }
+});
+
 function wrapCommandBuilder(target, builder) {
   const _target = target || ((cli) => cli);
   return (cli) => {
@@ -320,6 +1500,41 @@ function wrapCommandhandler(target, handler) {
   };
 }
 
+const visitor$3 = 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
+            });
+          }
+        }
+      }
+      return _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", {
@@ -342,11 +1557,11 @@ const visitor$2 = function(commandObject, cli) {
 };
 const options$2 = {};
 
-const commandHandlerInjections = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-    __proto__: null,
-    options: options$2,
-    visitor: visitor$2
-}, Symbol.toStringTag, { value: 'Module' }));
+const CommandHandlerInjections = new Plugin("built-in:command-handler-injections", {
+  created({ engine, builder, factoryOptions }) {
+    engine.globalCommandVisitor("command-handler-injections-visitor", visitor$2, options$2);
+  }
+});
 
 const visitor$1 = function(commandObject, cli) {
   if (commandObject.meta) {
@@ -360,11 +1575,14 @@ const visitor$1 = function(commandObject, cli) {
 };
 const options$1 = {};
 
-const getCommandMeta = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-    __proto__: null,
-    options: options$1,
-    visitor: visitor$1
-}, Symbol.toStringTag, { value: 'Module' }));
+const CommandMeta = new Plugin("built-in:command-meta", {
+  created({ engine, builder, factoryOptions }) {
+    engine.getMeta = function() {
+      return this._meta;
+    };
+    engine.globalCommandVisitor("command-meta-visitor", visitor$1, options$1);
+  }
+});
 
 const visitor = function(commandObject, engine, options2) {
   const { metaProp, envKey } = options2;
@@ -385,130 +1603,23 @@ const options = {
   envKey: "CLI_ENV"
 };
 
-const privateCommand = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-    __proto__: null,
-    options,
-    visitor
-}, Symbol.toStringTag, { value: 'Module' }));
-
-const commandVisitors = {
-  commandHandlerInjections,
-  getCommandMeta,
-  privateCommand
-};
-
-function createEngine(yargs) {
-  const xargs = yargs;
-  xargs._isPrivate = false;
-  xargs._globalCommandVisitors = {};
-  xargs._globalCommandVisitorsEnabled = /* @__PURE__ */ new Set([]);
-  xargs._meta = {
-    private: false
-  };
-  const originalCommandMethod = xargs.command;
-  xargs.originalCommand = originalCommandMethod;
-  xargs.command = command;
-  xargs.globalCommandVisitor = globalCommandVisitor;
-  xargs.globalCommandVisitorOptions = globalCommandVisitorOptions;
-  xargs.hasGlobalCommandVisitor = hasGlobalCommandVisitor;
-  xargs.disableGlobalCommandVisitors = disableGlobalCommandVisitors;
-  xargs.enableGlobalCommandVisitors = enableGlobalCommandVisitors;
-  xargs.isPrivate = isPrivate;
-  xargs.getMeta = getMeta;
-  return xargs.globalCommandVisitor("command-handler-injections-visitor", commandVisitors.commandHandlerInjections.visitor, commandVisitors.commandHandlerInjections.options).globalCommandVisitor("get-meta-command-visitor", commandVisitors.getCommandMeta.visitor, commandVisitors.getCommandMeta.options).globalCommandVisitor("private-command-visitor", commandVisitors.privateCommand.visitor, commandVisitors.privateCommand.options).strict().help();
-}
-function command(...args) {
-  const self = this;
-  if (args.length === 1) {
-    const visit = (cmdModule) => {
-      const cmdObj = {
-        ...cmdModule
-      };
-      let failOnFalsyReturn;
-      for (const name of self._globalCommandVisitorsEnabled) {
-        const globalVisitor = self._globalCommandVisitors[name];
-        if (!globalVisitor(cmdObj, self, globalVisitor.options)) {
-          failOnFalsyReturn = true;
-        }
-      }
-      return failOnFalsyReturn ? false : cmdObj;
-    };
-    if (args[0] instanceof Array) {
-      const cmdsArray = [];
-      for (const commandModule of args[0]) {
-        const visited = visit(commandModule);
-        if (visited)
-          cmdsArray.push(visited);
-      }
-      return self.originalCommand(cmdsArray);
-    } else {
-      const visited = visit(args[0]);
-      return visited ? self.originalCommand(visited) : self;
-    }
-  } else {
-    return self.originalCommand(...args);
+const PrivateCommands = new Plugin("built-in:private-commands", {
+  created({ engine, builder, factoryOptions }) {
+    engine.globalCommandVisitor("private-command-visitor", visitor, options);
   }
-}
-function globalCommandVisitor(name, visitor, defaultOptions = {}) {
-  this._globalCommandVisitors[name] = visitor;
-  return this.enableGlobalCommandVisitors([name]).globalCommandVisitorOptions(name, defaultOptions);
-}
-function globalCommandVisitorOptions(name, options) {
-  this._globalCommandVisitors[name].options = {
-    ...this._globalCommandVisitors[name].options,
-    ...options
-  };
-  return this;
-}
-function hasGlobalCommandVisitor(name) {
-  return Object.keys(this._globalCommandVisitors).includes(name);
-}
-function disableGlobalCommandVisitors(visitors = []) {
-  for (const name of visitors) {
-    if (this.hasGlobalCommandVisitor(name)) {
-      this._globalCommandVisitorsEnabled.delete(name);
-    } else {
-      throw new Error('Global command visitor: "' + name + '" not defined.');
-    }
-  }
-  return this;
-}
-function enableGlobalCommandVisitors(visitors = []) {
-  for (const name of visitors) {
-    if (this.hasGlobalCommandVisitor(name)) {
-      this._globalCommandVisitorsEnabled.add(name);
-    } else {
-      throw new Error('Global command visitor: "' + name + '" not defined.');
-    }
-  }
-  return this;
-}
-function isPrivate() {
-  return this._isPrivate;
-}
-function getMeta() {
-  return this._meta;
-}
-
-function CLIFactory(builder) {
-  const cli = function(argv) {
-    const engine = createEngine(Yargs(argv));
-    return builder(engine);
-  };
-  return cli;
-}
+});
 
 async function extractUsage(factory, recursive = false, args = [""], locale = "en") {
   const innerYargs = factory([""]);
   innerYargs.locale(locale);
   const doclet = {
-    command: void 0,
-    args: void 0,
-    aliases: void 0,
+    command: undefined,
+    args: undefined,
+    aliases: undefined,
     deprecated: false,
-    extractedUsage: void 0,
-    rawUsage: void 0,
-    children: recursive ? {} : void 0
+    extractedUsage: undefined,
+    rawUsage: undefined,
+    children: recursive ? {} : undefined
   };
   const parseCallback = function(err, argv, output) {
     if (err)
@@ -555,5 +1666,17 @@ globalThis.CLI = {
   InterfaceUtils,
   OutputUtils
 };
+CLIFactory.use(LoadEnvFile);
+CLIFactory.use(RegisterBumpVersionCommand);
+CLIFactory.use(RegisterChangelogCommand);
+CLIFactory.use(RegisterDocsCommands);
+CLIFactory.use(RegisterGitHooksCommands);
+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 };