mathjs 10.4.1 → 10.4.2

package/examples/node_modules/webpack-cli/lib/webpack-cli.js

@@ -1,1803 +1,2343 @@
-const fs = require('fs');
-const path = require('path');
-const { pathToFileURL } = require('url');
-const Module = require('module');
+const fs = require("fs");
+const path = require("path");
+const { pathToFileURL } = require("url");
+const util = require("util");
 
-const { program } = require('commander');
-const utils = require('./utils');
+const { program, Option } = require("commander");
+
+const WEBPACK_PACKAGE = process.env.WEBPACK_PACKAGE || "webpack";
+const WEBPACK_DEV_SERVER_PACKAGE = process.env.WEBPACK_DEV_SERVER_PACKAGE || "webpack-dev-server";
 
 class WebpackCLI {
-    constructor() {
-        // Global
-        this.webpack = require('webpack');
-        this.logger = utils.logger;
-        this.utils = utils;
-
-        // Initialize program
-        this.program = program;
-        this.program.name('webpack');
-        this.program.configureOutput({
-            writeErr: this.logger.error,
-            outputError: (str, write) => write(`Error: ${this.utils.capitalizeFirstLetter(str.replace(/^error:/, '').trim())}`),
-        });
+  constructor() {
+    this.colors = this.createColors();
+    this.logger = this.getLogger();
+
+    // Initialize program
+    this.program = program;
+    this.program.name("webpack");
+    this.program.configureOutput({
+      writeErr: this.logger.error,
+      outputError: (str, write) =>
+        write(`Error: ${this.capitalizeFirstLetter(str.replace(/^error:/, "").trim())}`),
+    });
+  }
+
+  capitalizeFirstLetter(str) {
+    if (typeof str !== "string") {
+      return "";
     }
 
-    async makeCommand(commandOptions, options, action) {
-        const alreadyLoaded = this.program.commands.find(
-            (command) => command.name() === commandOptions.name || command.aliases().includes(commandOptions.alias),
-        );
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
 
-        if (alreadyLoaded) {
-            return;
-        }
+  toKebabCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  }
 
-        const command = this.program.command(commandOptions.name, {
-            noHelp: commandOptions.noHelp,
-            hidden: commandOptions.hidden,
-            isDefault: commandOptions.isDefault,
-        });
+  createColors(useColor) {
+    const { createColors, isColorSupported } = require("colorette");
 
-        if (commandOptions.description) {
-            command.description(commandOptions.description);
-        }
+    let shouldUseColor;
 
-        if (commandOptions.usage) {
-            command.usage(commandOptions.usage);
-        }
+    if (useColor) {
+      shouldUseColor = useColor;
+    } else {
+      shouldUseColor = isColorSupported;
+    }
 
-        if (Array.isArray(commandOptions.alias)) {
-            command.aliases(commandOptions.alias);
-        } else {
-            command.alias(commandOptions.alias);
-        }
+    return { ...createColors({ useColor: shouldUseColor }), isColorSupported: shouldUseColor };
+  }
+
+  getLogger() {
+    return {
+      error: (val) => console.error(`[webpack-cli] ${this.colors.red(util.format(val))}`),
+      warn: (val) => console.warn(`[webpack-cli] ${this.colors.yellow(val)}`),
+      info: (val) => console.info(`[webpack-cli] ${this.colors.cyan(val)}`),
+      success: (val) => console.log(`[webpack-cli] ${this.colors.green(val)}`),
+      log: (val) => console.log(`[webpack-cli] ${val}`),
+      raw: (val) => console.log(val),
+    };
+  }
+
+  checkPackageExists(packageName) {
+    if (process.versions.pnp) {
+      return true;
+    }
 
-        if (commandOptions.pkg) {
-            command.pkg = commandOptions.pkg;
-        } else {
-            command.pkg = 'webpack-cli';
-        }
+    let dir = __dirname;
 
-        const { forHelp } = this.program;
-
-        let allDependenciesInstalled = true;
-
-        if (commandOptions.dependencies && commandOptions.dependencies.length > 0) {
-            for (const dependency of commandOptions.dependencies) {
-                const { packageExists } = this.utils;
-                const isPkgExist = packageExists(dependency);
-
-                if (isPkgExist) {
-                    continue;
-                } else if (!isPkgExist && forHelp) {
-                    allDependenciesInstalled = false;
-                    continue;
-                }
-
-                const { promptInstallation, colors } = this.utils;
-
-                try {
-                    await promptInstallation(dependency, () => {
-                        this.logger.error(
-                            `For using '${colors.green(commandOptions.name.split(' ')[0])}' command you need to install: '${colors.green(
-                                dependency,
-                            )}' package`,
-                        );
-                    });
-                } catch (error) {
-                    this.logger.error("Action Interrupted, use 'webpack-cli help' to see possible commands.");
-                    this.logger.error(error);
-                    process.exit(2);
-                }
-            }
+    do {
+      try {
+        if (fs.statSync(path.join(dir, "node_modules", packageName)).isDirectory()) {
+          return true;
         }
+      } catch (_error) {
+        // Nothing
+      }
+    } while (dir !== (dir = path.dirname(dir)));
+
+    return false;
+  }
+
+  getAvailablePackageManagers() {
+    const { sync } = require("execa");
+    const installers = ["npm", "yarn", "pnpm"];
+    const hasPackageManagerInstalled = (packageManager) => {
+      try {
+        sync(packageManager, ["--version"]);
+
+        return packageManager;
+      } catch (err) {
+        return false;
+      }
+    };
+    const availableInstallers = installers.filter((installer) =>
+      hasPackageManagerInstalled(installer),
+    );
+
+    if (!availableInstallers.length) {
+      this.logger.error("No package manager found.");
+
+      process.exit(2);
+    }
 
-        if (options) {
-            if (typeof options === 'function') {
-                if (forHelp && !allDependenciesInstalled) {
-                    command.description(
-                        `${commandOptions.description} To see all available options you need to install ${commandOptions.dependencies
-                            .map((dependency) => `'${dependency}'`)
-                            .join(',')}.`,
-                    );
-                    options = [];
-                } else {
-                    options = options();
-                }
-            }
-
-            options.forEach((optionForCommand) => {
-                this.makeOption(command, optionForCommand);
-            });
-        }
+    return availableInstallers;
+  }
 
-        command.action(action);
+  getDefaultPackageManager() {
+    const { sync } = require("execa");
+    const hasLocalNpm = fs.existsSync(path.resolve(process.cwd(), "package-lock.json"));
 
-        return command;
+    if (hasLocalNpm) {
+      return "npm";
     }
 
-    makeOption(command, option) {
-        let type = option.type;
-        let isMultipleTypes = Array.isArray(type);
-        let isOptional = false;
+    const hasLocalYarn = fs.existsSync(path.resolve(process.cwd(), "yarn.lock"));
 
-        if (isMultipleTypes) {
-            if (type.length === 1) {
-                type = type[0];
-                isMultipleTypes = false;
-            } else {
-                isOptional = type.includes(Boolean);
-            }
-        }
+    if (hasLocalYarn) {
+      return "yarn";
+    }
 
-        const isMultiple = option.multiple;
-        const isRequired = type !== Boolean && typeof type !== 'undefined';
+    const hasLocalPnpm = fs.existsSync(path.resolve(process.cwd(), "pnpm-lock.yaml"));
 
-        let flags = option.alias ? `-${option.alias}, --${option.name}` : `--${option.name}`;
+    if (hasLocalPnpm) {
+      return "pnpm";
+    }
 
-        if (isOptional) {
-            // `commander.js` recognizes [value] as an optional placeholder, making this flag work either as a string or a boolean
-            flags = `${flags} [value${isMultiple ? '...' : ''}]`;
-        } else if (isRequired) {
-            // <value> is a required placeholder for any non-Boolean types
-            flags = `${flags} <value${isMultiple ? '...' : ''}>`;
-        }
+    try {
+      // the sync function below will fail if npm is not installed,
+      // an error will be thrown
+      if (sync("npm", ["--version"])) {
+        return "npm";
+      }
+    } catch (e) {
+      // Nothing
+    }
 
-        // TODO `describe` used by `webpack-dev-server@3`
-        const description = option.description || option.describe || '';
-        const defaultValue = option.defaultValue;
-
-        if (type === Boolean) {
-            command.option(flags, description, defaultValue);
-        } else if (type === Number) {
-            let skipDefault = true;
-
-            command.option(
-                flags,
-                description,
-                (value, prev = []) => {
-                    if (defaultValue && isMultiple && skipDefault) {
-                        prev = [];
-                        skipDefault = false;
-                    }
-
-                    return isMultiple ? [].concat(prev).concat(Number(value)) : Number(value);
-                },
-                defaultValue,
-            );
-        } else if (type === String) {
-            let skipDefault = true;
-
-            command.option(
-                flags,
-                description,
-                (value, prev = []) => {
-                    if (defaultValue && isMultiple && skipDefault) {
-                        prev = [];
-                        skipDefault = false;
-                    }
-
-                    return isMultiple ? [].concat(prev).concat(value) : value;
-                },
-                defaultValue,
-            );
-        } else if (isMultipleTypes) {
-            let skipDefault = true;
-
-            command.option(
-                flags,
-                description,
-                (value, prev = []) => {
-                    if (defaultValue && isMultiple && skipDefault) {
-                        prev = [];
-                        skipDefault = false;
-                    }
-
-                    if (type.includes(Number)) {
-                        const numberValue = Number(value);
-
-                        if (!isNaN(numberValue)) {
-                            return isMultiple ? [].concat(prev).concat(numberValue) : numberValue;
-                        }
-                    }
-
-                    if (type.includes(String)) {
-                        return isMultiple ? [].concat(prev).concat(value) : value;
-                    }
-
-                    return value;
-                },
-                defaultValue,
-            );
-        } else {
-            command.option(flags, description, type, defaultValue);
-        }
+    try {
+      // the sync function below will fail if yarn is not installed,
+      // an error will be thrown
+      if (sync("yarn", ["--version"])) {
+        return "yarn";
+      }
+    } catch (e) {
+      // Nothing
+    }
 
-        if (option.negative) {
-            // commander requires explicitly adding the negated version of boolean flags
-            const negatedFlag = `--no-${option.name}`;
+    try {
+      // the sync function below will fail if pnpm is not installed,
+      // an error will be thrown
+      if (sync("pnpm", ["--version"])) {
+        return "pnpm";
+      }
+    } catch (e) {
+      this.logger.error("No package manager found.");
 
-            command.option(negatedFlag, option.negatedDescription ? option.negatedDescription : `Negative '${option.name}' option.`);
-        }
+      process.exit(2);
     }
+  }
 
-    getBuiltInOptions() {
-        if (this.builtInOptionsCache) {
-            return this.builtInOptionsCache;
-        }
+  async doInstall(packageName, options = {}) {
+    const packageManager = this.getDefaultPackageManager();
 
-        const minimumHelpFlags = [
-            'config',
-            'config-name',
-            'merge',
-            'env',
-            'mode',
-            'watch',
-            'watch-options-stdin',
-            'stats',
-            'devtool',
-            'entry',
-            'target',
-            'progress',
-            'json',
-            'name',
-            'output-path',
-        ];
-
-        const builtInFlags = [
-            // For configs
-            {
-                name: 'config',
-                alias: 'c',
-                type: String,
-                multiple: true,
-                description: 'Provide path to a webpack configuration file e.g. ./webpack.config.js.',
-            },
-            {
-                name: 'config-name',
-                type: String,
-                multiple: true,
-                description: 'Name of the configuration to use.',
-            },
-            {
-                name: 'merge',
-                alias: 'm',
-                type: Boolean,
-                description: "Merge two or more configurations using 'webpack-merge'.",
-            },
-            // Complex configs
-            {
-                name: 'env',
-                type: (value, previous = {}) => {
-                    // This ensures we're only splitting by the first `=`
-                    const [allKeys, val] = value.split(/=(.+)/, 2);
-                    const splitKeys = allKeys.split(/\.(?!$)/);
-
-                    let prevRef = previous;
-
-                    splitKeys.forEach((someKey, index) => {
-                        if (!prevRef[someKey]) {
-                            prevRef[someKey] = {};
-                        }
-
-                        if (typeof prevRef[someKey] === 'string') {
-                            prevRef[someKey] = {};
-                        }
-
-                        if (index === splitKeys.length - 1) {
-                            prevRef[someKey] = val || true;
-                        }
-
-                        prevRef = prevRef[someKey];
-                    });
-
-                    return previous;
-                },
-                multiple: true,
-                description: 'Environment passed to the configuration when it is a function.',
-            },
-            {
-                name: 'node-env',
-                type: String,
-                multiple: false,
-                description: 'Sets process.env.NODE_ENV to the specified value',
-            },
+    if (!packageManager) {
+      this.logger.error("Can't find package manager");
 
-            // Adding more plugins
-            {
-                name: 'hot',
-                alias: 'h',
-                type: Boolean,
-                negative: true,
-                description: 'Enables Hot Module Replacement',
-                negatedDescription: 'Disables Hot Module Replacement.',
-            },
-            {
-                name: 'analyze',
-                type: Boolean,
-                multiple: false,
-                description: 'It invokes webpack-bundle-analyzer plugin to get bundle information.',
-            },
-            {
-                name: 'progress',
-                type: [Boolean, String],
-                description: 'Print compilation progress during build.',
-            },
-            {
-                name: 'prefetch',
-                type: String,
-                description: 'Prefetch this request.',
-            },
+      process.exit(2);
+    }
 
-            // Output options
-            {
-                name: 'json',
-                type: [String, Boolean],
-                alias: 'j',
-                description: 'Prints result as JSON or store it in a file.',
-            },
+    if (options.preMessage) {
+      options.preMessage();
+    }
 
-            // For webpack@4
-            {
-                name: 'entry',
-                type: String,
-                multiple: true,
-                description: 'The entry point(s) of your application e.g. ./src/main.js.',
-            },
-            {
-                name: 'output-path',
-                alias: 'o',
-                type: String,
-                description: 'Output location of the file generated by webpack e.g. ./dist/.',
-            },
-            {
-                name: 'target',
-                alias: 't',
-                type: String,
-                multiple: this.webpack.cli !== undefined,
-                description: 'Sets the build target e.g. node.',
-            },
-            {
-                name: 'devtool',
-                type: String,
-                negative: true,
-                alias: 'd',
-                description: 'Determine source maps to use.',
-                negatedDescription: 'Do not generate source maps.',
-            },
-            {
-                name: 'mode',
-                type: String,
-                description: 'Defines the mode to pass to webpack.',
-            },
-            {
-                name: 'name',
-                type: String,
-                description: 'Name of the configuration. Used when loading multiple configurations.',
-            },
-            {
-                name: 'stats',
-                type: [String, Boolean],
-                negative: true,
-                description: 'It instructs webpack on how to treat the stats e.g. verbose.',
-                negatedDescription: 'Disable stats output.',
-            },
-            {
-                name: 'watch',
-                type: Boolean,
-                negative: true,
-                alias: 'w',
-                description: 'Watch for files changes.',
-                negatedDescription: 'Do not watch for file changes.',
-            },
-            {
-                name: 'watch-options-stdin',
-                type: Boolean,
-                negative: true,
-                description: 'Stop watching when stdin stream has ended.',
-                negatedDescription: 'Do not stop watching when stdin stream has ended.',
-            },
-        ];
-
-        // Extract all the flags being exported from core.
-        // A list of cli flags generated by core can be found here https://github.com/webpack/webpack/blob/master/test/__snapshots__/Cli.test.js.snap
-        const coreFlags = this.webpack.cli
-            ? Object.entries(this.webpack.cli.getArguments()).map(([flag, meta]) => {
-                  if (meta.simpleType === 'string') {
-                      meta.type = String;
-                  } else if (meta.simpleType === 'number') {
-                      meta.type = Number;
-                  } else {
-                      meta.type = Boolean;
-                      meta.negative = !flag.endsWith('-reset');
-                  }
+    // yarn uses 'add' command, rest npm and pnpm both use 'install'
+    const commandToBeRun = `${packageManager} ${[
+      packageManager === "yarn" ? "add" : "install",
+      "-D",
+      packageName,
+    ].join(" ")}`;
+
+    const prompt = ({ message, defaultResponse, stream }) => {
+      const readline = require("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: stream,
+      });
+
+      return new Promise((resolve) => {
+        rl.question(`${message} `, (answer) => {
+          // Close the stream
+          rl.close();
+
+          const response = (answer || defaultResponse).toLowerCase();
+
+          // Resolve with the input response
+          if (response === "y" || response === "yes") {
+            resolve(true);
+          } else {
+            resolve(false);
+          }
+        });
+      });
+    };
+
+    let needInstall;
+
+    try {
+      needInstall = await prompt({
+        message: `[webpack-cli] Would you like to install '${this.colors.green(
+          packageName,
+        )}' package? (That will run '${this.colors.green(commandToBeRun)}') (${this.colors.yellow(
+          "Y/n",
+        )})`,
+        defaultResponse: "Y",
+        stream: process.stderr,
+      });
+    } catch (error) {
+      this.logger.error(error);
+
+      process.exit(error);
+    }
 
-                  const inBuiltIn = builtInFlags.find((builtInFlag) => builtInFlag.name === flag);
+    if (needInstall) {
+      const execa = require("execa");
 
-                  if (inBuiltIn) {
-                      return { ...meta, name: flag, group: 'core', ...inBuiltIn };
-                  }
+      try {
+        await execa(commandToBeRun, [], { stdio: "inherit", shell: true });
+      } catch (error) {
+        this.logger.error(error);
 
-                  return { ...meta, name: flag, group: 'core' };
-              })
-            : [];
+        process.exit(2);
+      }
 
-        const options = []
-            .concat(builtInFlags.filter((builtInFlag) => !coreFlags.find((coreFlag) => builtInFlag.name === coreFlag.name)))
-            .concat(coreFlags)
-            .map((option) => {
-                option.help = minimumHelpFlags.includes(option.name) ? 'minimum' : 'verbose';
+      return packageName;
+    }
 
-                return option;
-            });
+    process.exit(2);
+  }
+
+  async tryRequireThenImport(module, handleError = true) {
+    let result;
+
+    try {
+      result = require(module);
+    } catch (error) {
+      const dynamicImportLoader = require("./utils/dynamic-import-loader")();
+      if (
+        (error.code === "ERR_REQUIRE_ESM" || process.env.WEBPACK_CLI_FORCE_LOAD_ESM_CONFIG) &&
+        pathToFileURL &&
+        dynamicImportLoader
+      ) {
+        const urlForConfig = pathToFileURL(module);
+
+        result = await dynamicImportLoader(urlForConfig);
+        result = result.default;
+
+        return result;
+      }
+
+      if (handleError) {
+        this.logger.error(error);
+        process.exit(2);
+      } else {
+        throw error;
+      }
+    }
 
-        this.builtInOptionsCache = options;
+    // For babel/typescript
+    if (result && typeof result === "object" && "default" in result) {
+      result = result.default || {};
+    }
 
-        return options;
+    return result || {};
+  }
+
+  loadJSONFile(pathToFile, handleError = true) {
+    let result;
+
+    try {
+      result = require(pathToFile);
+    } catch (error) {
+      if (handleError) {
+        this.logger.error(error);
+        process.exit(2);
+      } else {
+        throw error;
+      }
     }
 
-    applyNodeEnv(options) {
-        if (typeof options.nodeEnv === 'string') {
-            process.env.NODE_ENV = options.nodeEnv;
-        }
+    return result;
+  }
+
+  async makeCommand(commandOptions, options, action) {
+    const alreadyLoaded = this.program.commands.find(
+      (command) =>
+        command.name() === commandOptions.name.split(" ")[0] ||
+        command.aliases().includes(commandOptions.alias),
+    );
+
+    if (alreadyLoaded) {
+      return;
     }
 
-    async run(args, parseOptions) {
-        // Built-in internal commands
-        const buildCommandOptions = {
-            name: 'build [entries...]',
-            alias: ['bundle', 'b'],
-            description: 'Run webpack (default command, can be omitted).',
-            usage: '[entries...] [options]',
-        };
-        const watchCommandOptions = {
-            name: 'watch [entries...]',
-            alias: 'w',
-            description: 'Run webpack and watch for files changes.',
-            usage: '[entries...] [options]',
-        };
-        const versionCommandOptions = {
-            name: 'version [commands...]',
-            alias: 'v',
-            description: "Output the version number of 'webpack', 'webpack-cli' and 'webpack-dev-server' and commands.",
-        };
-        const helpCommandOptions = {
-            name: 'help [command] [option]',
-            alias: 'h',
-            description: 'Display help for commands and options.',
-        };
-        // Built-in external commands
-        const externalBuiltInCommandsInfo = [
-            {
-                name: 'serve [entries...]',
-                alias: 's',
-                pkg: '@webpack-cli/serve',
-            },
-            {
-                name: 'info',
-                alias: 'i',
-                pkg: '@webpack-cli/info',
-            },
-            {
-                name: 'init',
-                alias: 'c',
-                pkg: '@webpack-cli/init',
-            },
-            {
-                name: 'loader',
-                alias: 'l',
-                pkg: '@webpack-cli/generators',
-            },
-            {
-                name: 'plugin',
-                alias: 'p',
-                pkg: '@webpack-cli/generators',
-            },
-            {
-                name: 'migrate',
-                alias: 'm',
-                pkg: '@webpack-cli/migrate',
-            },
-            {
-                name: 'configtest [config-path]',
-                alias: 't',
-                pkg: '@webpack-cli/configtest',
-            },
-        ];
-
-        const knownCommands = [
-            buildCommandOptions,
-            watchCommandOptions,
-            versionCommandOptions,
-            helpCommandOptions,
-            ...externalBuiltInCommandsInfo,
-        ];
-        const getCommandName = (name) => name.split(' ')[0];
-        const isKnownCommand = (name) =>
-            knownCommands.find(
-                (command) =>
-                    getCommandName(command.name) === name ||
-                    (Array.isArray(command.alias) ? command.alias.includes(name) : command.alias === name),
-            );
-        const isCommand = (input, commandOptions) => {
-            const longName = getCommandName(commandOptions.name);
+    const command = this.program.command(commandOptions.name, {
+      noHelp: commandOptions.noHelp,
+      hidden: commandOptions.hidden,
+      isDefault: commandOptions.isDefault,
+    });
 
-            if (input === longName) {
-                return true;
-            }
+    if (commandOptions.description) {
+      command.description(commandOptions.description, commandOptions.argsDescription);
+    }
 
-            if (commandOptions.alias) {
-                if (Array.isArray(commandOptions.alias)) {
-                    return commandOptions.alias.includes(input);
-                } else {
-                    return commandOptions.alias === input;
-                }
-            }
+    if (commandOptions.usage) {
+      command.usage(commandOptions.usage);
+    }
 
-            return false;
-        };
-        const findCommandByName = (name) =>
-            this.program.commands.find((command) => name === command.name() || command.alias().includes(name));
-        const isOption = (value) => value.startsWith('-');
-        const isGlobalOption = (value) =>
-            value === '--color' ||
-            value === '--no-color' ||
-            value === '-v' ||
-            value === '--version' ||
-            value === '-h' ||
-            value === '--help';
-
-        const loadCommandByName = async (commandName, allowToInstall = false) => {
-            const isBuildCommandUsed = isCommand(commandName, buildCommandOptions);
-            const isWatchCommandUsed = isCommand(commandName, watchCommandOptions);
-
-            if (isBuildCommandUsed || isWatchCommandUsed) {
-                const options = this.getBuiltInOptions();
-
-                await this.makeCommand(
-                    isBuildCommandUsed ? buildCommandOptions : watchCommandOptions,
-                    isWatchCommandUsed ? options.filter((option) => option.name !== 'watch') : options,
-                    async (entries, options) => {
-                        if (entries.length > 0) {
-                            options.entry = [...entries, ...(options.entry || [])];
-                        }
-
-                        await this.buildCommand(options, isWatchCommandUsed);
-                    },
-                );
-            } else if (isCommand(commandName, helpCommandOptions)) {
-                // Stub for the `help` command
-                this.makeCommand(helpCommandOptions, [], () => {});
-            } else if (isCommand(commandName, versionCommandOptions)) {
-                // Stub for the `help` command
-                this.makeCommand(versionCommandOptions, [], () => {});
-            } else {
-                const builtInExternalCommandInfo = externalBuiltInCommandsInfo.find(
-                    (externalBuiltInCommandInfo) =>
-                        getCommandName(externalBuiltInCommandInfo.name) === commandName ||
-                        (Array.isArray(externalBuiltInCommandInfo.alias)
-                            ? externalBuiltInCommandInfo.alias.includes(commandName)
-                            : externalBuiltInCommandInfo.alias === commandName),
-                );
+    if (Array.isArray(commandOptions.alias)) {
+      command.aliases(commandOptions.alias);
+    } else {
+      command.alias(commandOptions.alias);
+    }
 
-                let pkg;
+    if (commandOptions.pkg) {
+      command.pkg = commandOptions.pkg;
+    } else {
+      command.pkg = "webpack-cli";
+    }
 
-                if (builtInExternalCommandInfo) {
-                    ({ pkg } = builtInExternalCommandInfo);
-                } else {
-                    pkg = commandName;
-                }
+    const { forHelp } = this.program;
 
-                if (pkg !== 'webpack-cli' && !this.utils.packageExists(pkg)) {
-                    if (!allowToInstall) {
-                        return;
-                    }
+    let allDependenciesInstalled = true;
 
-                    const { promptInstallation, colors } = this.utils;
+    if (commandOptions.dependencies && commandOptions.dependencies.length > 0) {
+      for (const dependency of commandOptions.dependencies) {
+        const isPkgExist = this.checkPackageExists(dependency);
 
-                    try {
-                        pkg = await promptInstallation(pkg, () => {
-                            this.logger.error(`For using this command you need to install: '${colors.green(pkg)}' package`);
-                        });
-                    } catch (error) {
-                        this.logger.error(`Action Interrupted, use '${colors.cyan('webpack-cli help')}' to see possible commands`);
-                        process.exit(2);
-                    }
-                }
+        if (isPkgExist) {
+          continue;
+        } else if (!isPkgExist && forHelp) {
+          allDependenciesInstalled = false;
+          continue;
+        }
 
-                let loadedCommand;
+        let skipInstallation = false;
 
-                try {
-                    loadedCommand = require(pkg);
-                } catch (error) {
-                    // Ignore, command is not installed
+        // Allow to use `./path/to/webpack.js` outside `node_modules`
+        if (dependency === WEBPACK_PACKAGE && fs.existsSync(WEBPACK_PACKAGE)) {
+          skipInstallation = true;
+        }
 
-                    return;
-                }
+        // Allow to use `./path/to/webpack-dev-server.js` outside `node_modules`
+        if (dependency === WEBPACK_DEV_SERVER_PACKAGE && fs.existsSync(WEBPACK_PACKAGE)) {
+          skipInstallation = true;
+        }
 
-                if (loadedCommand.default) {
-                    loadedCommand = loadedCommand.default;
-                }
+        if (skipInstallation) {
+          continue;
+        }
 
-                let command;
+        await this.doInstall(dependency, {
+          preMessage: () => {
+            this.logger.error(
+              `For using '${this.colors.green(
+                commandOptions.name.split(" ")[0],
+              )}' command you need to install: '${this.colors.green(dependency)}' package.`,
+            );
+          },
+        });
+      }
+    }
 
-                try {
-                    command = new loadedCommand();
+    if (options) {
+      if (typeof options === "function") {
+        if (forHelp && !allDependenciesInstalled) {
+          command.description(
+            `${
+              commandOptions.description
+            } To see all available options you need to install ${commandOptions.dependencies
+              .map((dependency) => `'${dependency}'`)
+              .join(", ")}.`,
+          );
+          options = [];
+        } else {
+          options = await options();
+        }
+      }
 
-                    await command.apply(this);
-                } catch (error) {
-                    this.logger.error(`Unable to load '${pkg}' command`);
-                    this.logger.error(error);
-                    process.exit(2);
-                }
-            }
-        };
+      options.forEach((optionForCommand) => {
+        this.makeOption(command, optionForCommand);
+      });
+    }
 
-        // Register own exit
-        this.program.exitOverride(async (error) => {
-            if (error.exitCode === 0) {
-                process.exit(0);
+    command.action(action);
+
+    return command;
+  }
+
+  makeOption(command, option) {
+    let mainOption;
+    let negativeOption;
+
+    if (option.configs) {
+      let needNegativeOption = false;
+      let negatedDescription;
+      const mainOptionType = new Set();
+
+      option.configs.forEach((config) => {
+        // Possible value: "enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset"
+        switch (config.type) {
+          case "reset":
+            mainOptionType.add(Boolean);
+            break;
+          case "boolean":
+            if (!needNegativeOption) {
+              needNegativeOption = true;
+              negatedDescription = config.negatedDescription;
             }
 
-            if (error.code === 'executeSubCommandAsync') {
-                process.exit(2);
-            }
+            mainOptionType.add(Boolean);
+            break;
+          case "number":
+            mainOptionType.add(Number);
+            break;
+          case "string":
+          case "path":
+          case "RegExp":
+            mainOptionType.add(String);
+            break;
+          case "enum": {
+            let hasFalseEnum = false;
+
+            const enumTypes = config.values.map((value) => {
+              switch (typeof value) {
+                case "string":
+                  mainOptionType.add(String);
+                  break;
+                case "number":
+                  mainOptionType.add(Number);
+                  break;
+                case "boolean":
+                  if (!hasFalseEnum && value === false) {
+                    hasFalseEnum = true;
+                    break;
+                  }
+
+                  mainOptionType.add(Boolean);
+                  break;
+              }
+            });
 
-            if (error.code === 'commander.help') {
-                process.exit(0);
+            if (!needNegativeOption) {
+              needNegativeOption = hasFalseEnum;
+              negatedDescription = config.negatedDescription;
             }
 
-            if (error.code === 'commander.unknownOption') {
-                let name = error.message.match(/'(.+)'/);
+            return enumTypes;
+          }
+        }
+      });
+
+      mainOption = {
+        flags: option.alias ? `-${option.alias}, --${option.name}` : `--${option.name}`,
+        description: option.description || "",
+        type: mainOptionType,
+        multiple: option.multiple,
+        defaultValue: option.defaultValue,
+      };
+
+      if (needNegativeOption) {
+        negativeOption = {
+          flags: `--no-${option.name}`,
+          description:
+            negatedDescription || option.negatedDescription || `Negative '${option.name}' option.`,
+        };
+      }
+    } else {
+      mainOption = {
+        flags: option.alias ? `-${option.alias}, --${option.name}` : `--${option.name}`,
+        // TODO `describe` used by `webpack-dev-server@3`
+        description: option.description || option.describe || "",
+        type: option.type
+          ? new Set(Array.isArray(option.type) ? option.type : [option.type])
+          : new Set([Boolean]),
+        multiple: option.multiple,
+        defaultValue: option.defaultValue,
+      };
+
+      if (option.negative) {
+        negativeOption = {
+          flags: `--no-${option.name}`,
+          description: option.negatedDescription
+            ? option.negatedDescription
+            : `Negative '${option.name}' option.`,
+        };
+      }
+    }
 
-                if (name) {
-                    name = name[1].substr(2);
+    if (mainOption.type.size > 1 && mainOption.type.has(Boolean)) {
+      mainOption.flags = `${mainOption.flags} [value${mainOption.multiple ? "..." : ""}]`;
+    } else if (mainOption.type.size > 0 && !mainOption.type.has(Boolean)) {
+      mainOption.flags = `${mainOption.flags} <value${mainOption.multiple ? "..." : ""}>`;
+    }
 
-                    if (name.includes('=')) {
-                        name = name.split('=')[0];
-                    }
+    if (mainOption.type.size === 1) {
+      if (mainOption.type.has(Number)) {
+        let skipDefault = true;
 
-                    const { operands } = this.program.parseOptions(this.program.args);
-                    const operand = typeof operands[0] !== 'undefined' ? operands[0] : getCommandName(buildCommandOptions.name);
+        const optionForCommand = new Option(mainOption.flags, mainOption.description)
+          .argParser((value, prev = []) => {
+            if (mainOption.defaultValue && mainOption.multiple && skipDefault) {
+              prev = [];
+              skipDefault = false;
+            }
 
-                    if (operand) {
-                        const command = findCommandByName(operand);
+            return mainOption.multiple ? [].concat(prev).concat(Number(value)) : Number(value);
+          })
+          .default(mainOption.defaultValue);
 
-                        if (!command) {
-                            this.logger.error(`Can't find and load command '${operand}'`);
-                            this.logger.error("Run 'webpack --help' to see available commands and options");
-                            process.exit(2);
-                        }
+        optionForCommand.helpLevel = option.helpLevel;
 
-                        command.options.forEach((option) => {
-                            if (this.utils.levenshtein.distance(name, option.long.slice(2)) < 3) {
-                                this.logger.error(`Did you mean '--${option.name()}'?`);
-                            }
-                        });
-                    }
-                }
+        command.addOption(optionForCommand);
+      } else if (mainOption.type.has(String)) {
+        let skipDefault = true;
+
+        const optionForCommand = new Option(mainOption.flags, mainOption.description)
+          .argParser((value, prev = []) => {
+            if (mainOption.defaultValue && mainOption.multiple && skipDefault) {
+              prev = [];
+              skipDefault = false;
             }
 
-            // Codes:
-            // - commander.unknownCommand
-            // - commander.missingArgument
-            // - commander.missingMandatoryOptionValue
-            // - commander.optionMissingArgument
+            return mainOption.multiple ? [].concat(prev).concat(value) : value;
+          })
+          .default(mainOption.defaultValue);
 
-            this.logger.error("Run 'webpack --help' to see available commands and options");
-            process.exit(2);
-        });
+        optionForCommand.helpLevel = option.helpLevel;
 
-        // Default `--color` and `--no-color` options
-        const cli = this;
-        this.program.option('--color', 'Enable colors on console.');
-        this.program.on('option:color', function () {
-            const { color } = this.opts();
+        command.addOption(optionForCommand);
+      } else if (mainOption.type.has(Boolean)) {
+        const optionForCommand = new Option(mainOption.flags, mainOption.description).default(
+          mainOption.defaultValue,
+        );
 
-            cli.utils.colors.options.changed = true;
-            cli.utils.colors.options.enabled = color;
-        });
-        this.program.option('--no-color', 'Disable colors on console.');
-        this.program.on('option:no-color', function () {
-            const { color } = this.opts();
+        optionForCommand.helpLevel = option.helpLevel;
+
+        command.addOption(optionForCommand);
+      } else {
+        const optionForCommand = new Option(mainOption.flags, mainOption.description)
+          .argParser(Array.from(mainOption.type)[0])
+          .default(mainOption.defaultValue);
+
+        optionForCommand.helpLevel = option.helpLevel;
+
+        command.addOption(optionForCommand);
+      }
+    } else if (mainOption.type.size > 1) {
+      let skipDefault = true;
+
+      const optionForCommand = new Option(
+        mainOption.flags,
+        mainOption.description,
+        mainOption.defaultValue,
+      )
+        .argParser((value, prev = []) => {
+          if (mainOption.defaultValue && mainOption.multiple && skipDefault) {
+            prev = [];
+            skipDefault = false;
+          }
+
+          if (mainOption.type.has(Number)) {
+            const numberValue = Number(value);
+
+            if (!isNaN(numberValue)) {
+              return mainOption.multiple ? [].concat(prev).concat(numberValue) : numberValue;
+            }
+          }
 
-            cli.utils.colors.options.changed = true;
-            cli.utils.colors.options.enabled = color;
-        });
+          if (mainOption.type.has(String)) {
+            return mainOption.multiple ? [].concat(prev).concat(value) : value;
+          }
 
-        // Make `-v, --version` options
-        // Make `version|v [commands...]` command
-        const outputVersion = async (options) => {
-            // Filter `bundle`, `watch`, `version` and `help` commands
-            const possibleCommandNames = options.filter(
-                (option) =>
-                    !isCommand(option, buildCommandOptions) &&
-                    !isCommand(option, watchCommandOptions) &&
-                    !isCommand(option, versionCommandOptions) &&
-                    !isCommand(option, helpCommandOptions),
-            );
+          return value;
+        })
+        .default(mainOption.defaultValue);
 
-            possibleCommandNames.forEach((possibleCommandName) => {
-                if (!isOption(possibleCommandName)) {
-                    return;
-                }
+      optionForCommand.helpLevel = option.helpLevel;
 
-                this.logger.error(`Unknown option '${possibleCommandName}'`);
-                this.logger.error("Run 'webpack --help' to see available commands and options");
-                process.exit(2);
-            });
+      command.addOption(optionForCommand);
+    } else if (mainOption.type.size === 0 && negativeOption) {
+      const optionForCommand = new Option(mainOption.flags, mainOption.description);
 
-            if (possibleCommandNames.length > 0) {
-                await Promise.all(possibleCommandNames.map((possibleCommand) => loadCommandByName(possibleCommand)));
+      // Hide stub option
+      optionForCommand.hideHelp();
+      optionForCommand.helpLevel = option.helpLevel;
 
-                for (const possibleCommandName of possibleCommandNames) {
-                    const foundCommand = findCommandByName(possibleCommandName);
+      command.addOption(optionForCommand);
+    }
 
-                    if (!foundCommand) {
-                        this.logger.error(`Unknown command '${possibleCommandName}'`);
-                        this.logger.error("Run 'webpack --help' to see available commands and options");
-                        process.exit(2);
-                    }
+    if (negativeOption) {
+      const optionForCommand = new Option(negativeOption.flags, negativeOption.description);
 
-                    try {
-                        const { name, version } = require(`${foundCommand.pkg}/package.json`);
+      optionForCommand.helpLevel = option.helpLevel;
 
-                        this.logger.raw(`${name} ${version}`);
-                    } catch (e) {
-                        this.logger.error(`Error: External package '${foundCommand.pkg}' not found`);
-                        process.exit(2);
-                    }
-                }
-            }
+      command.addOption(optionForCommand);
+    }
+  }
 
-            const pkgJSON = require('../package.json');
+  getBuiltInOptions() {
+    if (this.builtInOptionsCache) {
+      return this.builtInOptionsCache;
+    }
 
-            this.logger.raw(`webpack ${this.webpack.version}`);
-            this.logger.raw(`webpack-cli ${pkgJSON.version}`);
+    const minimumHelpFlags = [
+      "config",
+      "config-name",
+      "merge",
+      "env",
+      "mode",
+      "watch",
+      "watch-options-stdin",
+      "stats",
+      "devtool",
+      "entry",
+      "target",
+      "progress",
+      "json",
+      "name",
+      "output-path",
+      "node-env",
+    ];
+
+    const builtInFlags = [
+      // For configs
+      {
+        name: "config",
+        alias: "c",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        multiple: true,
+        description: "Provide path to a webpack configuration file e.g. ./webpack.config.js.",
+      },
+      {
+        name: "config-name",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        multiple: true,
+        description: "Name of the configuration to use.",
+      },
+      {
+        name: "merge",
+        alias: "m",
+        configs: [
+          {
+            type: "enum",
+            values: [true],
+          },
+        ],
+        description: "Merge two or more configurations using 'webpack-merge'.",
+      },
+      // Complex configs
+      {
+        name: "env",
+        type: (value, previous = {}) => {
+          // for https://github.com/webpack/webpack-cli/issues/2642
+          if (value.endsWith("=")) {
+            value.concat('""');
+          }
+
+          // This ensures we're only splitting by the first `=`
+          const [allKeys, val] = value.split(/=(.+)/, 2);
+          const splitKeys = allKeys.split(/\.(?!$)/);
+
+          let prevRef = previous;
+
+          splitKeys.forEach((someKey, index) => {
+            if (!prevRef[someKey]) {
+              prevRef[someKey] = {};
+            }
 
-            if (this.utils.packageExists('webpack-dev-server')) {
-                // eslint-disable-next-line
-                const { version } = require('webpack-dev-server/package.json');
+            if (typeof prevRef[someKey] === "string") {
+              prevRef[someKey] = {};
+            }
 
-                this.logger.raw(`webpack-dev-server ${version}`);
+            if (index === splitKeys.length - 1) {
+              if (typeof val === "string") {
+                prevRef[someKey] = val;
+              } else {
+                prevRef[someKey] = true;
+              }
             }
 
-            process.exit(0);
-        };
-        this.program.option(
-            '-v, --version',
-            "Output the version number of 'webpack', 'webpack-cli' and 'webpack-dev-server' and commands.",
+            prevRef = prevRef[someKey];
+          });
+
+          return previous;
+        },
+        multiple: true,
+        description: "Environment passed to the configuration when it is a function.",
+      },
+      {
+        name: "node-env",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        multiple: false,
+        description: "Sets process.env.NODE_ENV to the specified value.",
+      },
+
+      // Adding more plugins
+      {
+        name: "hot",
+        alias: "h",
+        configs: [
+          {
+            type: "string",
+          },
+          {
+            type: "boolean",
+          },
+        ],
+        negative: true,
+        description: "Enables Hot Module Replacement",
+        negatedDescription: "Disables Hot Module Replacement.",
+      },
+      {
+        name: "analyze",
+        configs: [
+          {
+            type: "enum",
+            values: [true],
+          },
+        ],
+        multiple: false,
+        description: "It invokes webpack-bundle-analyzer plugin to get bundle information.",
+      },
+      {
+        name: "progress",
+        configs: [
+          {
+            type: "string",
+          },
+          {
+            type: "enum",
+            values: [true],
+          },
+        ],
+        description: "Print compilation progress during build.",
+      },
+      {
+        name: "prefetch",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        description: "Prefetch this request.",
+      },
+
+      // Output options
+      {
+        name: "json",
+        configs: [
+          {
+            type: "string",
+          },
+          {
+            type: "enum",
+            values: [true],
+          },
+        ],
+        alias: "j",
+        description: "Prints result as JSON or store it in a file.",
+      },
+
+      // For webpack@4
+      {
+        name: "entry",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        multiple: true,
+        description: "The entry point(s) of your application e.g. ./src/main.js.",
+      },
+      {
+        name: "output-path",
+        alias: "o",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        description: "Output location of the file generated by webpack e.g. ./dist/.",
+      },
+      {
+        name: "target",
+        alias: "t",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        multiple: this.webpack.cli !== undefined,
+        description: "Sets the build target e.g. node.",
+      },
+      {
+        name: "devtool",
+        configs: [
+          {
+            type: "string",
+          },
+          {
+            type: "enum",
+            values: [false],
+          },
+        ],
+        negative: true,
+        alias: "d",
+        description: "Determine source maps to use.",
+        negatedDescription: "Do not generate source maps.",
+      },
+      {
+        name: "mode",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        description: "Defines the mode to pass to webpack.",
+      },
+      {
+        name: "name",
+        configs: [
+          {
+            type: "string",
+          },
+        ],
+        description: "Name of the configuration. Used when loading multiple configurations.",
+      },
+      {
+        name: "stats",
+        configs: [
+          {
+            type: "string",
+          },
+          {
+            type: "boolean",
+          },
+        ],
+        negative: true,
+        description: "It instructs webpack on how to treat the stats e.g. verbose.",
+        negatedDescription: "Disable stats output.",
+      },
+      {
+        name: "watch",
+        configs: [
+          {
+            type: "boolean",
+          },
+        ],
+        negative: true,
+        alias: "w",
+        description: "Watch for files changes.",
+        negatedDescription: "Do not watch for file changes.",
+      },
+      {
+        name: "watch-options-stdin",
+        configs: [
+          {
+            type: "boolean",
+          },
+        ],
+        negative: true,
+        description: "Stop watching when stdin stream has ended.",
+        negatedDescription: "Do not stop watching when stdin stream has ended.",
+      },
+    ];
+
+    // Extract all the flags being exported from core.
+    // A list of cli flags generated by core can be found here https://github.com/webpack/webpack/blob/master/test/__snapshots__/Cli.test.js.snap
+    const coreFlags = this.webpack.cli
+      ? Object.entries(this.webpack.cli.getArguments()).map(([flag, meta]) => {
+          const inBuiltIn = builtInFlags.find((builtInFlag) => builtInFlag.name === flag);
+
+          if (inBuiltIn) {
+            return {
+              ...meta,
+              name: flag,
+              group: "core",
+              ...inBuiltIn,
+              configs: meta.configs || [],
+            };
+          }
+
+          return { ...meta, name: flag, group: "core" };
+        })
+      : [];
+
+    const options = []
+      .concat(
+        builtInFlags.filter(
+          (builtInFlag) => !coreFlags.find((coreFlag) => builtInFlag.name === coreFlag.name),
+        ),
+      )
+      .concat(coreFlags)
+      .map((option) => {
+        option.helpLevel = minimumHelpFlags.includes(option.name) ? "minimum" : "verbose";
+
+        return option;
+      });
+
+    this.builtInOptionsCache = options;
+
+    return options;
+  }
+
+  async loadWebpack(handleError = true) {
+    return this.tryRequireThenImport(WEBPACK_PACKAGE, handleError);
+  }
+
+  async run(args, parseOptions) {
+    // Built-in internal commands
+    const buildCommandOptions = {
+      name: "build [entries...]",
+      alias: ["bundle", "b"],
+      description: "Run webpack (default command, can be omitted).",
+      usage: "[entries...] [options]",
+      dependencies: [WEBPACK_PACKAGE],
+    };
+    const watchCommandOptions = {
+      name: "watch [entries...]",
+      alias: "w",
+      description: "Run webpack and watch for files changes.",
+      usage: "[entries...] [options]",
+      dependencies: [WEBPACK_PACKAGE],
+    };
+    const versionCommandOptions = {
+      name: "version [commands...]",
+      alias: "v",
+      description:
+        "Output the version number of 'webpack', 'webpack-cli' and 'webpack-dev-server' and commands.",
+    };
+    const helpCommandOptions = {
+      name: "help [command] [option]",
+      alias: "h",
+      description: "Display help for commands and options.",
+    };
+    // Built-in external commands
+    const externalBuiltInCommandsInfo = [
+      {
+        name: "serve [entries...]",
+        alias: ["server", "s"],
+        pkg: "@webpack-cli/serve",
+      },
+      {
+        name: "info",
+        alias: "i",
+        pkg: "@webpack-cli/info",
+      },
+      {
+        name: "init",
+        alias: ["create", "new", "c", "n"],
+        pkg: "@webpack-cli/generators",
+      },
+      {
+        name: "loader",
+        alias: "l",
+        pkg: "@webpack-cli/generators",
+      },
+      {
+        name: "plugin",
+        alias: "p",
+        pkg: "@webpack-cli/generators",
+      },
+      {
+        name: "migrate",
+        alias: "m",
+        pkg: "@webpack-cli/migrate",
+      },
+      {
+        name: "configtest [config-path]",
+        alias: "t",
+        pkg: "@webpack-cli/configtest",
+      },
+    ];
+
+    const knownCommands = [
+      buildCommandOptions,
+      watchCommandOptions,
+      versionCommandOptions,
+      helpCommandOptions,
+      ...externalBuiltInCommandsInfo,
+    ];
+    const getCommandName = (name) => name.split(" ")[0];
+    const isKnownCommand = (name) =>
+      knownCommands.find(
+        (command) =>
+          getCommandName(command.name) === name ||
+          (Array.isArray(command.alias) ? command.alias.includes(name) : command.alias === name),
+      );
+    const isCommand = (input, commandOptions) => {
+      const longName = getCommandName(commandOptions.name);
+
+      if (input === longName) {
+        return true;
+      }
+
+      if (commandOptions.alias) {
+        if (Array.isArray(commandOptions.alias)) {
+          return commandOptions.alias.includes(input);
+        } else {
+          return commandOptions.alias === input;
+        }
+      }
+
+      return false;
+    };
+    const findCommandByName = (name) =>
+      this.program.commands.find(
+        (command) => name === command.name() || command.aliases().includes(name),
+      );
+    const isOption = (value) => value.startsWith("-");
+    const isGlobalOption = (value) =>
+      value === "--color" ||
+      value === "--no-color" ||
+      value === "-v" ||
+      value === "--version" ||
+      value === "-h" ||
+      value === "--help";
+
+    const loadCommandByName = async (commandName, allowToInstall = false) => {
+      const isBuildCommandUsed = isCommand(commandName, buildCommandOptions);
+      const isWatchCommandUsed = isCommand(commandName, watchCommandOptions);
+
+      if (isBuildCommandUsed || isWatchCommandUsed) {
+        await this.makeCommand(
+          isBuildCommandUsed ? buildCommandOptions : watchCommandOptions,
+          async () => {
+            this.webpack = await this.loadWebpack();
+
+            return isWatchCommandUsed
+              ? this.getBuiltInOptions().filter((option) => option.name !== "watch")
+              : this.getBuiltInOptions();
+          },
+          async (entries, options) => {
+            if (entries.length > 0) {
+              options.entry = [...entries, ...(options.entry || [])];
+            }
+
+            await this.runWebpack(options, isWatchCommandUsed);
+          },
+        );
+      } else if (isCommand(commandName, helpCommandOptions)) {
+        // Stub for the `help` command
+        this.makeCommand(helpCommandOptions, [], () => {});
+      } else if (isCommand(commandName, versionCommandOptions)) {
+        // Stub for the `version` command
+        this.makeCommand(versionCommandOptions, [], () => {});
+      } else {
+        const builtInExternalCommandInfo = externalBuiltInCommandsInfo.find(
+          (externalBuiltInCommandInfo) =>
+            getCommandName(externalBuiltInCommandInfo.name) === commandName ||
+            (Array.isArray(externalBuiltInCommandInfo.alias)
+              ? externalBuiltInCommandInfo.alias.includes(commandName)
+              : externalBuiltInCommandInfo.alias === commandName),
         );
 
-        const outputHelp = async (options, isVerbose, isHelpCommandSyntax, program) => {
-            const { bold } = this.utils.colors;
+        let pkg;
 
-            const outputIncorrectUsageOfHelp = () => {
-                this.logger.error('Incorrect use of help');
-                this.logger.error("Please use: 'webpack help [command] [option]' | 'webpack [command] --help'");
-                this.logger.error("Run 'webpack --help' to see available commands and options");
-                process.exit(2);
-            };
+        if (builtInExternalCommandInfo) {
+          ({ pkg } = builtInExternalCommandInfo);
+        } else {
+          pkg = commandName;
+        }
 
-            const isGlobalHelp = options.length === 0;
-            const isCommandHelp = options.length === 1 && !isOption(options[0]);
-
-            if (isGlobalHelp || isCommandHelp) {
-                const cliAPI = this;
-
-                program.configureHelp({
-                    sortSubcommands: true,
-                    // Support multiple aliases
-                    commandUsage: (command) => {
-                        let parentCmdNames = '';
-
-                        for (let parentCmd = command.parent; parentCmd; parentCmd = parentCmd.parent) {
-                            parentCmdNames = `${parentCmd.name()} ${parentCmdNames}`;
-                        }
-
-                        if (isGlobalHelp) {
-                            return `${parentCmdNames}${command.usage()}\n${this.utils.colors.bold(
-                                'Alternative usage to run commands:',
-                            )} ${parentCmdNames}[command] [options]`;
-                        }
-
-                        return `${parentCmdNames}${command.name()}|${command.aliases().join('|')} ${command.usage()}`;
-                    },
-                    // Support multiple aliases
-                    subcommandTerm: (command) => {
-                        const humanReadableArgumentName = (argument) => {
-                            const nameOutput = argument.name + (argument.variadic === true ? '...' : '');
-
-                            return argument.required ? '<' + nameOutput + '>' : '[' + nameOutput + ']';
-                        };
-                        const args = command._args.map((arg) => humanReadableArgumentName(arg)).join(' ');
-
-                        return `${command.name()}|${command.aliases().join('|')}${args ? ` ${args}` : ''}${
-                            command.options.length > 0 ? ' [options]' : ''
-                        }`;
-                    },
-                    visibleOptions: function visibleOptions(command) {
-                        const options = cliAPI.getBuiltInOptions();
-
-                        return command.options.filter((option) => {
-                            if (option.hidden) {
-                                return false;
-                            }
-
-                            if (!isVerbose) {
-                                const foundOption = options.find((flag) => {
-                                    if (option.negate && flag.negative) {
-                                        return `no-${flag.name}` === option.name();
-                                    }
-
-                                    return flag.name === option.name();
-                                });
-
-                                if (foundOption) {
-                                    return foundOption.help === 'minimum';
-                                }
-
-                                return true;
-                            }
-
-                            return true;
-                        });
-                    },
-                    padWidth(command, helper) {
-                        return Math.max(
-                            helper.longestArgumentTermLength(command, helper),
-                            helper.longestOptionTermLength(command, helper),
-                            // For global options
-                            helper.longestOptionTermLength(program, helper),
-                            helper.longestSubcommandTermLength(isGlobalHelp ? program : command, helper),
-                        );
-                    },
-                    formatHelp: (command, helper) => {
-                        const termWidth = helper.padWidth(command, helper);
-                        const helpWidth = helper.helpWidth || 80;
-                        const itemIndentWidth = 2;
-                        const itemSeparatorWidth = 2; // between term and description
-
-                        const formatItem = (term, description) => {
-                            if (description) {
-                                const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-
-                                return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-                            }
-
-                            return term;
-                        };
-
-                        const formatList = (textArray) => textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
-
-                        // Usage
-                        let output = [`${bold('Usage:')} ${helper.commandUsage(command)}`, ''];
-
-                        // Description
-                        const commandDescription = isGlobalHelp
-                            ? 'The build tool for modern web applications.'
-                            : helper.commandDescription(command);
-
-                        if (commandDescription.length > 0) {
-                            output = output.concat([commandDescription, '']);
-                        }
-
-                        // Arguments
-                        const argumentList = helper
-                            .visibleArguments(command)
-                            .map((argument) => formatItem(argument.term, argument.description));
-
-                        if (argumentList.length > 0) {
-                            output = output.concat([bold('Arguments:'), formatList(argumentList), '']);
-                        }
-
-                        // Options
-                        const optionList = helper
-                            .visibleOptions(command)
-                            .map((option) => formatItem(helper.optionTerm(option), helper.optionDescription(option)));
-
-                        if (optionList.length > 0) {
-                            output = output.concat([bold('Options:'), formatList(optionList), '']);
-                        }
-
-                        // Global options
-                        const globalOptionList = program.options.map((option) =>
-                            formatItem(helper.optionTerm(option), helper.optionDescription(option)),
-                        );
-
-                        if (globalOptionList.length > 0) {
-                            output = output.concat([bold('Global options:'), formatList(globalOptionList), '']);
-                        }
-
-                        // Commands
-                        const commandList = helper
-                            .visibleCommands(isGlobalHelp ? program : command)
-                            .map((command) => formatItem(helper.subcommandTerm(command), helper.subcommandDescription(command)));
-
-                        if (commandList.length > 0) {
-                            output = output.concat([bold('Commands:'), formatList(commandList), '']);
-                        }
-
-                        return output.join('\n');
-                    },
-                });
-
-                if (isGlobalHelp) {
-                    await Promise.all(
-                        knownCommands.map((knownCommand) => {
-                            return loadCommandByName(getCommandName(knownCommand.name));
-                        }),
-                    );
-
-                    const buildCommand = findCommandByName(getCommandName(buildCommandOptions.name));
-
-                    this.logger.raw(buildCommand.helpInformation());
-                } else {
-                    const name = options[0];
-
-                    await loadCommandByName(name);
-
-                    const command = findCommandByName(name);
-
-                    if (!command) {
-                        this.logger.error(`Can't find and load command '${name}'`);
-                        this.logger.error("Run 'webpack --help' to see available commands and options");
-                        process.exit(2);
-                    }
-
-                    this.logger.raw(command.helpInformation());
-                }
-            } else if (isHelpCommandSyntax) {
-                let isCommandSpecified = false;
-                let commandName = getCommandName(buildCommandOptions.name);
-                let optionName;
-
-                if (options.length === 1) {
-                    optionName = options[0];
-                } else if (options.length === 2) {
-                    isCommandSpecified = true;
-                    commandName = options[0];
-                    optionName = options[1];
-
-                    if (isOption(commandName)) {
-                        outputIncorrectUsageOfHelp();
-                    }
-                } else {
-                    outputIncorrectUsageOfHelp();
-                }
-
-                await loadCommandByName(commandName);
-
-                const command = isGlobalOption(optionName) ? program : findCommandByName(commandName);
-
-                if (!command) {
-                    this.logger.error(`Can't find and load command '${commandName}'`);
-                    this.logger.error("Run 'webpack --help' to see available commands and options");
-                    process.exit(2);
-                }
-
-                const option = command.options.find((option) => option.short === optionName || option.long === optionName);
-
-                if (!option) {
-                    this.logger.error(`Unknown option '${optionName}'`);
-                    this.logger.error("Run 'webpack --help' to see available commands and options");
-                    process.exit(2);
-                }
-
-                const nameOutput =
-                    option.flags.replace(/^.+[[<]/, '').replace(/(\.\.\.)?[\]>].*$/, '') + (option.variadic === true ? '...' : '');
-                const value = option.required ? '<' + nameOutput + '>' : option.optional ? '[' + nameOutput + ']' : '';
-
-                this.logger.raw(
-                    `${bold('Usage')}: webpack${isCommandSpecified ? ` ${commandName}` : ''} ${option.long}${value ? ` ${value}` : ''}`,
-                );
+        if (pkg !== "webpack-cli" && !this.checkPackageExists(pkg)) {
+          if (!allowToInstall) {
+            return;
+          }
 
-                if (option.short) {
-                    this.logger.raw(
-                        `${bold('Short:')} webpack${isCommandSpecified ? ` ${commandName}` : ''} ${option.short}${
-                            value ? ` ${value}` : ''
-                        }`,
-                    );
-                }
+          pkg = await this.doInstall(pkg, {
+            preMessage: () => {
+              this.logger.error(
+                `For using this command you need to install: '${this.colors.green(pkg)}' package.`,
+              );
+            },
+          });
+        }
 
-                if (option.description) {
-                    this.logger.raw(`${bold('Description:')} ${option.description}`);
-                }
+        let loadedCommand;
 
-                if (!option.negate && options.defaultValue) {
-                    this.logger.raw(`${bold('Default value:')} ${JSON.stringify(option.defaultValue)}`);
-                }
+        try {
+          loadedCommand = await this.tryRequireThenImport(pkg, false);
+        } catch (error) {
+          // Ignore, command is not installed
 
-                this.logger.raw('');
+          return;
+        }
 
-                // TODO implement this after refactor cli arguments
-                // logger.raw('Possible values: foo | bar');
-                // logger.raw('Documentation: https://webpack.js.org/option/name/');
-            } else {
-                outputIncorrectUsageOfHelp();
-            }
+        let command;
 
-            this.logger.raw("To see list of all supported commands and options run 'webpack --help=verbose'.\n");
-            this.logger.raw(`${bold('Webpack documentation:')} https://webpack.js.org/.`);
-            this.logger.raw(`${bold('CLI documentation:')} https://webpack.js.org/api/cli/.`);
-            this.logger.raw(`${bold('Made with ♥ by the webpack team')}.`);
-            process.exit(0);
-        };
-        this.program.helpOption(false);
-        this.program.addHelpCommand(false);
-        this.program.option('-h, --help [verbose]', 'Display help for commands and options.');
-
-        let isInternalActionCalled = false;
-
-        // Default action
-        this.program.usage('[options]');
-        this.program.allowUnknownOption(true);
-        this.program.action(async (options, program) => {
-            if (!isInternalActionCalled) {
-                isInternalActionCalled = true;
-            } else {
-                this.logger.error('No commands found to run');
-                process.exit(2);
+        try {
+          command = new loadedCommand();
+
+          await command.apply(this);
+        } catch (error) {
+          this.logger.error(`Unable to load '${pkg}' command`);
+          this.logger.error(error);
+          process.exit(2);
+        }
+      }
+    };
+
+    // Register own exit
+    this.program.exitOverride(async (error) => {
+      if (error.exitCode === 0) {
+        process.exit(0);
+      }
+
+      if (error.code === "executeSubCommandAsync") {
+        process.exit(2);
+      }
+
+      if (error.code === "commander.help") {
+        process.exit(0);
+      }
+
+      if (error.code === "commander.unknownOption") {
+        let name = error.message.match(/'(.+)'/);
+
+        if (name) {
+          name = name[1].substr(2);
+
+          if (name.includes("=")) {
+            name = name.split("=")[0];
+          }
+
+          const { operands } = this.program.parseOptions(this.program.args);
+          const operand =
+            typeof operands[0] !== "undefined"
+              ? operands[0]
+              : getCommandName(buildCommandOptions.name);
+
+          if (operand) {
+            const command = findCommandByName(operand);
+
+            if (!command) {
+              this.logger.error(`Can't find and load command '${operand}'`);
+              this.logger.error("Run 'webpack --help' to see available commands and options");
+              process.exit(2);
             }
 
-            // Command and options
-            const { operands, unknown } = this.program.parseOptions(program.args);
-            const defaultCommandToRun = getCommandName(buildCommandOptions.name);
-            const hasOperand = typeof operands[0] !== 'undefined';
-            const operand = hasOperand ? operands[0] : defaultCommandToRun;
+            const levenshtein = require("fastest-levenshtein");
+
+            command.options.forEach((option) => {
+              if (!option.hidden && levenshtein.distance(name, option.long.slice(2)) < 3) {
+                this.logger.error(`Did you mean '--${option.name()}'?`);
+              }
+            });
+          }
+        }
+      }
+
+      // Codes:
+      // - commander.unknownCommand
+      // - commander.missingArgument
+      // - commander.missingMandatoryOptionValue
+      // - commander.optionMissingArgument
+
+      this.logger.error("Run 'webpack --help' to see available commands and options");
+      process.exit(2);
+    });
+
+    // Default `--color` and `--no-color` options
+    const cli = this;
+    this.program.option("--color", "Enable colors on console.");
+    this.program.on("option:color", function () {
+      const { color } = this.opts();
+
+      cli.isColorSupportChanged = color;
+      cli.colors = cli.createColors(color);
+    });
+    this.program.option("--no-color", "Disable colors on console.");
+    this.program.on("option:no-color", function () {
+      const { color } = this.opts();
+
+      cli.isColorSupportChanged = color;
+      cli.colors = cli.createColors(color);
+    });
+
+    // Make `-v, --version` options
+    // Make `version|v [commands...]` command
+    const outputVersion = async (options) => {
+      // Filter `bundle`, `watch`, `version` and `help` commands
+      const possibleCommandNames = options.filter(
+        (option) =>
+          !isCommand(option, buildCommandOptions) &&
+          !isCommand(option, watchCommandOptions) &&
+          !isCommand(option, versionCommandOptions) &&
+          !isCommand(option, helpCommandOptions),
+      );
+
+      possibleCommandNames.forEach((possibleCommandName) => {
+        if (!isOption(possibleCommandName)) {
+          return;
+        }
 
-            const isHelpCommandSyntax = isCommand(operand, helpCommandOptions);
+        this.logger.error(`Unknown option '${possibleCommandName}'`);
+        this.logger.error("Run 'webpack --help' to see available commands and options");
+        process.exit(2);
+      });
 
-            if (options.help || isHelpCommandSyntax) {
-                let isVerbose = false;
+      if (possibleCommandNames.length > 0) {
+        await Promise.all(
+          possibleCommandNames.map((possibleCommand) => loadCommandByName(possibleCommand)),
+        );
 
-                if (options.help) {
-                    if (typeof options.help === 'string') {
-                        if (options.help !== 'verbose') {
-                            this.logger.error("Unknown value for '--help' option, please use '--help=verbose'");
-                            process.exit(2);
-                        }
+        for (const possibleCommandName of possibleCommandNames) {
+          const foundCommand = findCommandByName(possibleCommandName);
 
-                        isVerbose = true;
-                    }
-                }
+          if (!foundCommand) {
+            this.logger.error(`Unknown command '${possibleCommandName}'`);
+            this.logger.error("Run 'webpack --help' to see available commands and options");
+            process.exit(2);
+          }
 
-                this.program.forHelp = true;
+          try {
+            const { name, version } = this.loadJSONFile(`${foundCommand.pkg}/package.json`);
 
-                const optionsForHelp = []
-                    .concat(options.help && hasOperand ? [operand] : [])
-                    // Syntax `webpack help [command]`
-                    .concat(operands.slice(1))
-                    // Syntax `webpack help [option]`
-                    .concat(unknown)
-                    .concat(isHelpCommandSyntax && typeof options.color !== 'undefined' ? [options.color ? '--color' : '--no-color'] : [])
-                    .concat(isHelpCommandSyntax && typeof options.version !== 'undefined' ? ['--version'] : []);
+            this.logger.raw(`${name} ${version}`);
+          } catch (e) {
+            this.logger.error(`Error: External package '${foundCommand.pkg}' not found`);
+            process.exit(2);
+          }
+        }
+      }
 
-                await outputHelp(optionsForHelp, isVerbose, isHelpCommandSyntax, program);
-            }
+      let webpack;
 
-            if (options.version || isCommand(operand, versionCommandOptions)) {
-                const optionsForVersion = []
-                    .concat(options.version ? [operand] : [])
-                    .concat(operands.slice(1))
-                    .concat(unknown);
+      try {
+        webpack = await this.loadWebpack(false);
+      } catch (_error) {
+        // Nothing
+      }
 
-                await outputVersion(optionsForVersion, program);
-            }
+      this.logger.raw(`webpack: ${webpack ? webpack.version : "not installed"}`);
 
-            let commandToRun = operand;
-            let commandOperands = operands.slice(1);
+      const pkgJSON = this.loadJSONFile("../package.json");
 
-            if (isKnownCommand(commandToRun)) {
-                await loadCommandByName(commandToRun, true);
-            } else {
-                let isEntrySyntax = fs.existsSync(operand);
-
-                if (isEntrySyntax) {
-                    commandToRun = defaultCommandToRun;
-                    commandOperands = operands;
-
-                    await loadCommandByName(commandToRun);
-                } else {
-                    this.logger.error(`Unknown command or entry '${operand}'`);
-
-                    const found = knownCommands.find(
-                        (commandOptions) => this.utils.levenshtein.distance(operand, getCommandName(commandOptions.name)) < 3,
-                    );
-
-                    if (found) {
-                        this.logger.error(
-                            `Did you mean '${getCommandName(found.name)}' (alias '${
-                                Array.isArray(found.alias) ? found.alias.join(', ') : found.alias
-                            }')?`,
-                        );
-                    }
-
-                    this.logger.error("Run 'webpack --help' to see available commands and options");
-                    process.exit(2);
-                }
-            }
+      this.logger.raw(`webpack-cli: ${pkgJSON.version}`);
 
-            await this.program.parseAsync([commandToRun, ...commandOperands, ...unknown], { from: 'user' });
-        });
+      let devServer;
 
-        await this.program.parseAsync(args, parseOptions);
-    }
+      try {
+        devServer = await this.loadJSONFile("webpack-dev-server/package.json", false);
+      } catch (_error) {
+        // Nothing
+      }
 
-    async resolveConfig(options) {
-        const loadConfig = async (configPath) => {
-            const { interpret } = this.utils;
-            const ext = path.extname(configPath);
-            const interpreted = Object.keys(interpret.jsVariants).find((variant) => variant === ext);
-
-            if (interpreted) {
-                const { rechoir } = this.utils;
-
-                try {
-                    rechoir.prepare(interpret.extensions, configPath);
-                } catch (error) {
-                    if (error.failures) {
-                        this.logger.error(`Unable load '${configPath}'`);
-                        this.logger.error(error.message);
-
-                        error.failures.forEach((failure) => {
-                            this.logger.error(failure.error.message);
-                        });
-                        this.logger.error('Please install one of them');
-                        process.exit(2);
-                    }
-
-                    this.logger.error(error);
-                    process.exit(2);
-                }
-            }
+      this.logger.raw(`webpack-dev-server ${devServer ? devServer.version : "not installed"}`);
 
-            let options;
+      process.exit(0);
+    };
+    this.program.option(
+      "-v, --version",
+      "Output the version number of 'webpack', 'webpack-cli' and 'webpack-dev-server' and commands.",
+    );
 
-            try {
-                try {
-                    options = require(configPath);
-                } catch (error) {
-                    let previousModuleCompile;
+    const outputHelp = async (options, isVerbose, isHelpCommandSyntax, program) => {
+      const { bold } = this.colors;
+      const outputIncorrectUsageOfHelp = () => {
+        this.logger.error("Incorrect use of help");
+        this.logger.error(
+          "Please use: 'webpack help [command] [option]' | 'webpack [command] --help'",
+        );
+        this.logger.error("Run 'webpack --help' to see available commands and options");
+        process.exit(2);
+      };
+
+      const isGlobalHelp = options.length === 0;
+      const isCommandHelp = options.length === 1 && !isOption(options[0]);
+
+      if (isGlobalHelp || isCommandHelp) {
+        program.configureHelp({
+          sortSubcommands: true,
+          // Support multiple aliases
+          commandUsage: (command) => {
+            let parentCmdNames = "";
+
+            for (let parentCmd = command.parent; parentCmd; parentCmd = parentCmd.parent) {
+              parentCmdNames = `${parentCmd.name()} ${parentCmdNames}`;
+            }
 
-                    // TODO Workaround https://github.com/zertosh/v8-compile-cache/issues/30
-                    if (this._originalModuleCompile) {
-                        previousModuleCompile = Module.prototype._compile;
+            if (isGlobalHelp) {
+              return `${parentCmdNames}${command.usage()}\n${bold(
+                "Alternative usage to run commands:",
+              )} ${parentCmdNames}[command] [options]`;
+            }
 
-                        Module.prototype._compile = this._originalModuleCompile;
-                    }
+            return `${parentCmdNames}${command.name()}|${command
+              .aliases()
+              .join("|")} ${command.usage()}`;
+          },
+          // Support multiple aliases
+          subcommandTerm: (command) => {
+            const humanReadableArgumentName = (argument) => {
+              const nameOutput = argument.name + (argument.variadic === true ? "..." : "");
 
-                    const dynamicImportLoader = this.utils.dynamicImportLoader();
+              return argument.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+            };
+            const args = command._args.map((arg) => humanReadableArgumentName(arg)).join(" ");
+
+            return `${command.name()}|${command.aliases().join("|")}${args ? ` ${args}` : ""}${
+              command.options.length > 0 ? " [options]" : ""
+            }`;
+          },
+          visibleOptions: function visibleOptions(command) {
+            return command.options.filter((option) => {
+              if (option.hidden) {
+                return false;
+              }
+
+              switch (option.helpLevel) {
+                case "verbose":
+                  return isVerbose;
+                case "minimum":
+                default:
+                  return true;
+              }
+            });
+          },
+          padWidth(command, helper) {
+            return Math.max(
+              helper.longestArgumentTermLength(command, helper),
+              helper.longestOptionTermLength(command, helper),
+              // For global options
+              helper.longestOptionTermLength(program, helper),
+              helper.longestSubcommandTermLength(isGlobalHelp ? program : command, helper),
+            );
+          },
+          formatHelp: (command, helper) => {
+            const termWidth = helper.padWidth(command, helper);
+            const helpWidth = helper.helpWidth || process.env.WEBPACK_CLI_HELP_WIDTH || 80;
+            const itemIndentWidth = 2;
+            const itemSeparatorWidth = 2; // between term and description
+
+            const formatItem = (term, description) => {
+              if (description) {
+                const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+
+                return helper.wrap(
+                  fullText,
+                  helpWidth - itemIndentWidth,
+                  termWidth + itemSeparatorWidth,
+                );
+              }
 
-                    if (this._originalModuleCompile) {
-                        Module.prototype._compile = previousModuleCompile;
-                    }
+              return term;
+            };
 
-                    if (
-                        (error.code === 'ERR_REQUIRE_ESM' || process.env.WEBPACK_CLI_FORCE_LOAD_ESM_CONFIG) &&
-                        pathToFileURL &&
-                        dynamicImportLoader
-                    ) {
-                        const urlForConfig = pathToFileURL(configPath);
+            const formatList = (textArray) =>
+              textArray.join("\n").replace(/^/gm, " ".repeat(itemIndentWidth));
 
-                        options = await dynamicImportLoader(urlForConfig);
-                        options = options.default;
+            // Usage
+            let output = [`${bold("Usage:")} ${helper.commandUsage(command)}`, ""];
 
-                        return { options, path: configPath };
-                    }
+            // Description
+            const commandDescription = isGlobalHelp
+              ? "The build tool for modern web applications."
+              : helper.commandDescription(command);
 
-                    throw error;
-                }
-            } catch (error) {
-                this.logger.error(`Failed to load '${configPath}' config`);
+            if (commandDescription.length > 0) {
+              output = output.concat([commandDescription, ""]);
+            }
 
-                if (this.isValidationError(error)) {
-                    this.logger.error(error.message);
-                } else {
-                    this.logger.error(error);
-                }
+            // Arguments
+            const argumentList = helper
+              .visibleArguments(command)
+              .map((argument) => formatItem(argument.term, argument.description));
 
-                process.exit(2);
+            if (argumentList.length > 0) {
+              output = output.concat([bold("Arguments:"), formatList(argumentList), ""]);
             }
 
-            if (options.default) {
-                options = options.default;
+            // Options
+            const optionList = helper
+              .visibleOptions(command)
+              .map((option) =>
+                formatItem(helper.optionTerm(option), helper.optionDescription(option)),
+              );
+
+            if (optionList.length > 0) {
+              output = output.concat([bold("Options:"), formatList(optionList), ""]);
             }
 
-            return { options, path: configPath };
-        };
+            // Global options
+            const globalOptionList = program.options.map((option) =>
+              formatItem(helper.optionTerm(option), helper.optionDescription(option)),
+            );
 
-        const evaluateConfig = async (loadedConfig, argv) => {
-            const isMultiCompiler = Array.isArray(loadedConfig.options);
-            const config = isMultiCompiler ? loadedConfig.options : [loadedConfig.options];
+            if (globalOptionList.length > 0) {
+              output = output.concat([bold("Global options:"), formatList(globalOptionList), ""]);
+            }
 
-            let evaluatedConfig = await Promise.all(
-                config.map(async (rawConfig) => {
-                    if (typeof rawConfig.then === 'function') {
-                        rawConfig = await rawConfig;
-                    }
+            // Commands
+            const commandList = helper
+              .visibleCommands(isGlobalHelp ? program : command)
+              .map((command) =>
+                formatItem(helper.subcommandTerm(command), helper.subcommandDescription(command)),
+              );
 
-                    // `Promise` may return `Function`
-                    if (typeof rawConfig === 'function') {
-                        // when config is a function, pass the env from args to the config function
-                        rawConfig = await rawConfig(argv.env, argv);
-                    }
+            if (commandList.length > 0) {
+              output = output.concat([bold("Commands:"), formatList(commandList), ""]);
+            }
 
-                    return rawConfig;
-                }),
-            );
+            return output.join("\n");
+          },
+        });
 
-            loadedConfig.options = isMultiCompiler ? evaluatedConfig : evaluatedConfig[0];
+        if (isGlobalHelp) {
+          await Promise.all(
+            knownCommands.map((knownCommand) => {
+              return loadCommandByName(getCommandName(knownCommand.name));
+            }),
+          );
 
-            const isObject = (value) => typeof value === 'object' && value !== null;
+          const buildCommand = findCommandByName(getCommandName(buildCommandOptions.name));
 
-            if (!isObject(loadedConfig.options) && !Array.isArray(loadedConfig.options)) {
-                this.logger.error(`Invalid configuration in '${loadedConfig.path}'`);
-                process.exit(2);
-            }
+          this.logger.raw(buildCommand.helpInformation());
+        } else {
+          const name = options[0];
 
-            return loadedConfig;
-        };
+          await loadCommandByName(name);
 
-        let config = { options: {}, path: new WeakMap() };
+          const command = findCommandByName(name);
 
-        if (options.config && options.config.length > 0) {
-            const evaluatedConfigs = await Promise.all(
-                options.config.map(async (value) => evaluateConfig(await loadConfig(path.resolve(value)), options.argv || {})),
+          if (!command) {
+            const builtInCommandUsed = externalBuiltInCommandsInfo.find(
+              (command) => command.name.includes(name) || name === command.alias,
             );
+            if (typeof builtInCommandUsed !== "undefined") {
+              this.logger.error(
+                `For using '${name}' command you need to install '${builtInCommandUsed.pkg}' package.`,
+              );
+            } else {
+              this.logger.error(`Can't find and load command '${name}'`);
+              this.logger.error("Run 'webpack --help' to see available commands and options.");
+            }
+            process.exit(2);
+          }
 
-            config.options = [];
-
-            evaluatedConfigs.forEach((evaluatedConfig) => {
-                if (Array.isArray(evaluatedConfig.options)) {
-                    evaluatedConfig.options.forEach((options) => {
-                        config.options.push(options);
-                        config.path.set(options, evaluatedConfig.path);
-                    });
-                } else {
-                    config.options.push(evaluatedConfig.options);
-                    config.path.set(evaluatedConfig.options, evaluatedConfig.path);
-                }
-            });
-
-            config.options = config.options.length === 1 ? config.options[0] : config.options;
+          this.logger.raw(command.helpInformation());
+        }
+      } else if (isHelpCommandSyntax) {
+        let isCommandSpecified = false;
+        let commandName = getCommandName(buildCommandOptions.name);
+        let optionName;
+
+        if (options.length === 1) {
+          optionName = options[0];
+        } else if (options.length === 2) {
+          isCommandSpecified = true;
+          commandName = options[0];
+          optionName = options[1];
+
+          if (isOption(commandName)) {
+            outputIncorrectUsageOfHelp();
+          }
         } else {
-            const { interpret } = this.utils;
-
-            // Order defines the priority, in increasing order
-            const defaultConfigFiles = ['webpack.config', '.webpack/webpack.config', '.webpack/webpackfile']
-                .map((filename) =>
-                    // Since .cjs is not available on interpret side add it manually to default config extension list
-                    [...Object.keys(interpret.extensions), '.cjs'].map((ext) => ({
-                        path: path.resolve(filename + ext),
-                        ext: ext,
-                        module: interpret.extensions[ext],
-                    })),
-                )
-                .reduce((accumulator, currentValue) => accumulator.concat(currentValue), []);
-
-            let foundDefaultConfigFile;
-
-            for (const defaultConfigFile of defaultConfigFiles) {
-                if (!fs.existsSync(defaultConfigFile.path)) {
-                    continue;
-                }
-
-                foundDefaultConfigFile = defaultConfigFile;
-                break;
-            }
+          outputIncorrectUsageOfHelp();
+        }
 
-            if (foundDefaultConfigFile) {
-                const loadedConfig = await loadConfig(foundDefaultConfigFile.path);
-                const evaluatedConfig = await evaluateConfig(loadedConfig, options.argv || {});
+        await loadCommandByName(commandName);
 
-                config.options = evaluatedConfig.options;
+        const command = isGlobalOption(optionName) ? program : findCommandByName(commandName);
 
-                if (Array.isArray(config.options)) {
-                    config.options.forEach((options) => {
-                        config.path.set(options, evaluatedConfig.path);
-                    });
-                } else {
-                    config.path.set(evaluatedConfig.options, evaluatedConfig.path);
-                }
-            }
+        if (!command) {
+          this.logger.error(`Can't find and load command '${commandName}'`);
+          this.logger.error("Run 'webpack --help' to see available commands and options");
+          process.exit(2);
         }
 
-        if (options.configName) {
-            const notfoundConfigNames = [];
+        const option = command.options.find(
+          (option) => option.short === optionName || option.long === optionName,
+        );
 
-            config.options = options.configName.map((configName) => {
-                let found;
+        if (!option) {
+          this.logger.error(`Unknown option '${optionName}'`);
+          this.logger.error("Run 'webpack --help' to see available commands and options");
+          process.exit(2);
+        }
 
-                if (Array.isArray(config.options)) {
-                    found = config.options.find((options) => options.name === configName);
-                } else {
-                    found = config.options.name === configName ? config.options : undefined;
-                }
+        const nameOutput =
+          option.flags.replace(/^.+[[<]/, "").replace(/(\.\.\.)?[\]>].*$/, "") +
+          (option.variadic === true ? "..." : "");
+        const value = option.required
+          ? "<" + nameOutput + ">"
+          : option.optional
+          ? "[" + nameOutput + "]"
+          : "";
+
+        this.logger.raw(
+          `${bold("Usage")}: webpack${isCommandSpecified ? ` ${commandName}` : ""} ${option.long}${
+            value ? ` ${value}` : ""
+          }`,
+        );
 
-                if (!found) {
-                    notfoundConfigNames.push(configName);
-                }
+        if (option.short) {
+          this.logger.raw(
+            `${bold("Short:")} webpack${isCommandSpecified ? ` ${commandName}` : ""} ${
+              option.short
+            }${value ? ` ${value}` : ""}`,
+          );
+        }
 
-                return found;
-            });
+        if (option.description) {
+          this.logger.raw(`${bold("Description:")} ${option.description}`);
+        }
 
-            if (notfoundConfigNames.length > 0) {
-                this.logger.error(
-                    notfoundConfigNames.map((configName) => `Configuration with the name "${configName}" was not found.`).join(' '),
-                );
-                process.exit(2);
-            }
+        if (!option.negate && option.defaultValue) {
+          this.logger.raw(`${bold("Default value:")} ${JSON.stringify(option.defaultValue)}`);
         }
 
-        if (options.merge) {
-            const { merge } = require('webpack-merge');
+        const flag = this.getBuiltInOptions().find((flag) => option.long === `--${flag.name}`);
 
-            // we can only merge when there are multiple configurations
-            // either by passing multiple configs by flags or passing a
-            // single config exporting an array
-            if (!Array.isArray(config.options) || config.options.length <= 1) {
-                this.logger.error('At least two configurations are required for merge.');
-                process.exit(2);
+        if (flag && flag.configs) {
+          const possibleValues = flag.configs.reduce((accumulator, currentValue) => {
+            if (currentValue.values) {
+              return accumulator.concat(currentValue.values);
+            } else {
+              return accumulator;
             }
+          }, []);
 
-            const mergedConfigPaths = [];
-
-            config.options = config.options.reduce((accumulator, options) => {
-                const configPath = config.path.get(options);
-                const mergedOptions = merge(accumulator, options);
+          if (possibleValues.length > 0) {
+            this.logger.raw(
+              `${bold("Possible values:")} ${JSON.stringify(possibleValues.join(" | "))}`,
+            );
+          }
+        }
 
-                mergedConfigPaths.push(configPath);
+        this.logger.raw("");
+
+        // TODO implement this after refactor cli arguments
+        // logger.raw('Documentation: https://webpack.js.org/option/name/');
+      } else {
+        outputIncorrectUsageOfHelp();
+      }
+
+      this.logger.raw(
+        "To see list of all supported commands and options run 'webpack --help=verbose'.\n",
+      );
+      this.logger.raw(`${bold("Webpack documentation:")} https://webpack.js.org/.`);
+      this.logger.raw(`${bold("CLI documentation:")} https://webpack.js.org/api/cli/.`);
+      this.logger.raw(`${bold("Made with ♥ by the webpack team")}.`);
+      process.exit(0);
+    };
+    this.program.helpOption(false);
+    this.program.addHelpCommand(false);
+    this.program.option("-h, --help [verbose]", "Display help for commands and options.");
+
+    let isInternalActionCalled = false;
+
+    // Default action
+    this.program.usage("[options]");
+    this.program.allowUnknownOption(true);
+    this.program.action(async (options, program) => {
+      if (!isInternalActionCalled) {
+        isInternalActionCalled = true;
+      } else {
+        this.logger.error("No commands found to run");
+        process.exit(2);
+      }
+
+      // Command and options
+      const { operands, unknown } = this.program.parseOptions(program.args);
+      const defaultCommandToRun = getCommandName(buildCommandOptions.name);
+      const hasOperand = typeof operands[0] !== "undefined";
+      const operand = hasOperand ? operands[0] : defaultCommandToRun;
+      const isHelpOption = typeof options.help !== "undefined";
+      const isHelpCommandSyntax = isCommand(operand, helpCommandOptions);
+
+      if (isHelpOption || isHelpCommandSyntax) {
+        let isVerbose = false;
+
+        if (isHelpOption) {
+          if (typeof options.help === "string") {
+            if (options.help !== "verbose") {
+              this.logger.error("Unknown value for '--help' option, please use '--help=verbose'");
+              process.exit(2);
+            }
 
-                return mergedOptions;
-            }, {});
-            config.path.set(config.options, mergedConfigPaths);
+            isVerbose = true;
+          }
         }
 
-        return config;
-    }
+        this.program.forHelp = true;
+
+        const optionsForHelp = []
+          .concat(isHelpOption && hasOperand ? [operand] : [])
+          // Syntax `webpack help [command]`
+          .concat(operands.slice(1))
+          // Syntax `webpack help [option]`
+          .concat(unknown)
+          .concat(
+            isHelpCommandSyntax && typeof options.color !== "undefined"
+              ? [options.color ? "--color" : "--no-color"]
+              : [],
+          )
+          .concat(
+            isHelpCommandSyntax && typeof options.version !== "undefined" ? ["--version"] : [],
+          );
+
+        await outputHelp(optionsForHelp, isVerbose, isHelpCommandSyntax, program);
+      }
+
+      const isVersionOption = typeof options.version !== "undefined";
+      const isVersionCommandSyntax = isCommand(operand, versionCommandOptions);
+
+      if (isVersionOption || isVersionCommandSyntax) {
+        const optionsForVersion = []
+          .concat(isVersionOption ? [operand] : [])
+          .concat(operands.slice(1))
+          .concat(unknown);
+
+        await outputVersion(optionsForVersion, program);
+      }
+
+      let commandToRun = operand;
+      let commandOperands = operands.slice(1);
+
+      if (isKnownCommand(commandToRun)) {
+        await loadCommandByName(commandToRun, true);
+      } else {
+        const isEntrySyntax = fs.existsSync(operand);
+
+        if (isEntrySyntax) {
+          commandToRun = defaultCommandToRun;
+          commandOperands = operands;
+
+          await loadCommandByName(commandToRun);
+        } else {
+          this.logger.error(`Unknown command or entry '${operand}'`);
+
+          const levenshtein = require("fastest-levenshtein");
+          const found = knownCommands.find(
+            (commandOptions) =>
+              levenshtein.distance(operand, getCommandName(commandOptions.name)) < 3,
+          );
+
+          if (found) {
+            this.logger.error(
+              `Did you mean '${getCommandName(found.name)}' (alias '${
+                Array.isArray(found.alias) ? found.alias.join(", ") : found.alias
+              }')?`,
+            );
+          }
 
-    // TODO refactor
-    async applyOptions(config, options) {
-        if (options.analyze) {
-            if (!this.utils.packageExists('webpack-bundle-analyzer')) {
-                const { promptInstallation, colors } = this.utils;
-
-                try {
-                    await promptInstallation('webpack-bundle-analyzer', () => {
-                        this.logger.error(`It looks like ${colors.yellow('webpack-bundle-analyzer')} is not installed.`);
-                    });
-                } catch (error) {
-                    this.logger.error(
-                        `Action Interrupted, Please try once again or install ${colors.yellow('webpack-bundle-analyzer')} manually.`,
-                    );
-                    process.exit(2);
-                }
-
-                this.logger.success(`${colors.yellow('webpack-bundle-analyzer')} was installed successfully.`);
-            }
+          this.logger.error("Run 'webpack --help' to see available commands and options");
+          process.exit(2);
         }
+      }
 
-        if (typeof options.progress === 'string' && options.progress !== 'profile') {
-            this.logger.error(`'${options.progress}' is an invalid value for the --progress option. Only 'profile' is allowed.`);
-            process.exit(2);
-        }
+      await this.program.parseAsync([commandToRun, ...commandOperands, ...unknown], {
+        from: "user",
+      });
+    });
 
-        const outputHints = (configOptions) => {
-            if (
-                configOptions.watch &&
-                options.argv &&
-                options.argv.env &&
-                (options.argv.env['WEBPACK_WATCH'] || options.argv.env['WEBPACK_SERVE'])
-            ) {
-                this.logger.warn(
-                    `No need to use the '${
-                        options.argv.env['WEBPACK_WATCH'] ? 'watch' : 'serve'
-                    }' command together with '{ watch: true }' configuration, it does not make sense.`,
-                );
+    await this.program.parseAsync(args, parseOptions);
+  }
 
-                if (options.argv.env['WEBPACK_SERVE']) {
-                    configOptions.watch = false;
-                }
-            }
+  async loadConfig(options) {
+    const interpret = require("interpret");
+    const loadConfigByPath = async (configPath, argv = {}) => {
+      const ext = path.extname(configPath);
+      const interpreted = Object.keys(interpret.jsVariants).find((variant) => variant === ext);
 
-            return configOptions;
-        };
+      if (interpreted) {
+        const rechoir = require("rechoir");
+
+        try {
+          rechoir.prepare(interpret.extensions, configPath);
+        } catch (error) {
+          if (error.failures) {
+            this.logger.error(`Unable load '${configPath}'`);
+            this.logger.error(error.message);
+            error.failures.forEach((failure) => {
+              this.logger.error(failure.error.message);
+            });
+            this.logger.error("Please install one of them");
+            process.exit(2);
+          }
 
-        config.options = Array.isArray(config.options)
-            ? config.options.map((options) => outputHints(options))
-            : outputHints(config.options);
+          this.logger.error(error);
+          process.exit(2);
+        }
+      }
 
-        if (this.webpack.cli) {
-            const processArguments = (configOptions) => {
-                const args = this.getBuiltInOptions()
-                    .filter((flag) => flag.group === 'core')
-                    .reduce((accumulator, flag) => {
-                        accumulator[flag.name] = flag;
+      let options;
 
-                        return accumulator;
-                    }, {});
+      try {
+        options = await this.tryRequireThenImport(configPath, false);
+      } catch (error) {
+        this.logger.error(`Failed to load '${configPath}' config`);
+
+        if (this.isValidationError(error)) {
+          this.logger.error(error.message);
+        } else {
+          this.logger.error(error);
+        }
 
-                const values = Object.keys(options).reduce((accumulator, name) => {
-                    if (name === 'argv') {
-                        return accumulator;
-                    }
+        process.exit(2);
+      }
 
-                    const kebabName = this.utils.toKebabCase(name);
+      if (Array.isArray(options)) {
+        await Promise.all(
+          options.map(async (_, i) => {
+            if (typeof options[i].then === "function") {
+              options[i] = await options[i];
+            }
 
-                    if (args[kebabName]) {
-                        accumulator[kebabName] = options[name];
-                    }
+            // `Promise` may return `Function`
+            if (typeof options[i] === "function") {
+              // when config is a function, pass the env from args to the config function
+              options[i] = await options[i](argv.env, argv);
+            }
+          }),
+        );
+      } else {
+        if (typeof options.then === "function") {
+          options = await options;
+        }
 
-                    return accumulator;
-                }, {});
+        // `Promise` may return `Function`
+        if (typeof options === "function") {
+          // when config is a function, pass the env from args to the config function
+          options = await options(argv.env, argv);
+        }
+      }
 
-                const problems = this.webpack.cli.processArguments(args, configOptions, values);
+      const isObject = (value) => typeof value === "object" && value !== null;
 
-                if (problems) {
-                    const groupBy = (xs, key) => {
-                        return xs.reduce((rv, x) => {
-                            (rv[x[key]] = rv[x[key]] || []).push(x);
+      if (!isObject(options) && !Array.isArray(options)) {
+        this.logger.error(`Invalid configuration in '${configPath}'`);
 
-                            return rv;
-                        }, {});
-                    };
-                    const problemsByPath = groupBy(problems, 'path');
+        process.exit(2);
+      }
 
-                    for (const path in problemsByPath) {
-                        const problems = problemsByPath[path];
+      return { options, path: configPath };
+    };
 
-                        problems.forEach((problem) => {
-                            this.logger.error(
-                                `${this.utils.capitalizeFirstLetter(problem.type.replace(/-/g, ' '))}${
-                                    problem.value ? ` '${problem.value}'` : ''
-                                } for the '--${problem.argument}' option${problem.index ? ` by index '${problem.index}'` : ''}`,
-                            );
+    const config = { options: {}, path: new WeakMap() };
 
-                            if (problem.expected) {
-                                this.logger.error(`Expected: '${problem.expected}'`);
-                            }
-                        });
-                    }
+    if (options.config && options.config.length > 0) {
+      const loadedConfigs = await Promise.all(
+        options.config.map((configPath) =>
+          loadConfigByPath(path.resolve(configPath), options.argv),
+        ),
+      );
 
-                    process.exit(2);
-                }
+      config.options = [];
 
-                return configOptions;
-            };
+      loadedConfigs.forEach((loadedConfig) => {
+        const isArray = Array.isArray(loadedConfig.options);
 
-            config.options = Array.isArray(config.options)
-                ? config.options.map((options) => processArguments(options))
-                : processArguments(config.options);
-
-            const setupDefaultOptions = (configOptions) => {
-                // No need to run for webpack@4
-                if (configOptions.cache && configOptions.cache.type === 'filesystem') {
-                    const configPath = config.path.get(configOptions);
-
-                    if (configPath) {
-                        if (!configOptions.cache.buildDependencies) {
-                            configOptions.cache.buildDependencies = {};
-                        }
-
-                        if (!configOptions.cache.buildDependencies.defaultConfig) {
-                            configOptions.cache.buildDependencies.defaultConfig = [];
-                        }
-
-                        if (Array.isArray(configPath)) {
-                            configPath.forEach((item) => {
-                                configOptions.cache.buildDependencies.defaultConfig.push(item);
-                            });
-                        } else {
-                            configOptions.cache.buildDependencies.defaultConfig.push(configPath);
-                        }
-                    }
-                }
-
-                return configOptions;
-            };
+        // TODO we should run webpack multiple times when the `--config` options have multiple values with `--merge`, need to solve for the next major release
+        if (config.options.length === 0) {
+          config.options = loadedConfig.options;
+        } else {
+          if (!Array.isArray(config.options)) {
+            config.options = [config.options];
+          }
 
-            config.options = Array.isArray(config.options)
-                ? config.options.map((options) => setupDefaultOptions(options))
-                : setupDefaultOptions(config.options);
+          if (isArray) {
+            loadedConfig.options.forEach((item) => {
+              config.options.push(item);
+            });
+          } else {
+            config.options.push(loadedConfig.options);
+          }
         }
 
-        // Logic for webpack@4
-        // TODO remove after drop webpack@4
-        const processLegacyArguments = (configOptions) => {
-            if (options.entry) {
-                configOptions.entry = options.entry;
-            }
+        if (isArray) {
+          loadedConfig.options.forEach((options) => {
+            config.path.set(options, loadedConfig.path);
+          });
+        } else {
+          config.path.set(loadedConfig.options, loadedConfig.path);
+        }
+      });
+
+      config.options = config.options.length === 1 ? config.options[0] : config.options;
+    } else {
+      // Order defines the priority, in decreasing order
+      const defaultConfigFiles = [
+        "webpack.config",
+        ".webpack/webpack.config",
+        ".webpack/webpackfile",
+      ]
+        .map((filename) =>
+          // Since .cjs is not available on interpret side add it manually to default config extension list
+          [...Object.keys(interpret.extensions), ".cjs"].map((ext) => ({
+            path: path.resolve(filename + ext),
+            ext: ext,
+            module: interpret.extensions[ext],
+          })),
+        )
+        .reduce((accumulator, currentValue) => accumulator.concat(currentValue), []);
+
+      let foundDefaultConfigFile;
+
+      for (const defaultConfigFile of defaultConfigFiles) {
+        if (!fs.existsSync(defaultConfigFile.path)) {
+          continue;
+        }
 
-            if (options.outputPath) {
-                configOptions.output = {
-                    ...configOptions.output,
-                    ...{ path: path.resolve(options.outputPath) },
-                };
-            }
+        foundDefaultConfigFile = defaultConfigFile;
+        break;
+      }
 
-            if (options.target) {
-                configOptions.target = options.target;
-            }
+      if (foundDefaultConfigFile) {
+        const loadedConfig = await loadConfigByPath(foundDefaultConfigFile.path, options.argv);
 
-            if (typeof options.devtool !== 'undefined') {
-                configOptions.devtool = options.devtool;
-            }
+        config.options = loadedConfig.options;
 
-            if (options.mode) {
-                configOptions.mode = options.mode;
-            } else if (
-                !configOptions.mode &&
-                process.env &&
-                process.env.NODE_ENV &&
-                (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'production' || process.env.NODE_ENV === 'none')
-            ) {
-                configOptions.mode = process.env.NODE_ENV;
-            }
+        if (Array.isArray(config.options)) {
+          config.options.forEach((item) => {
+            config.path.set(item, loadedConfig.path);
+          });
+        } else {
+          config.path.set(loadedConfig.options, loadedConfig.path);
+        }
+      }
+    }
 
-            if (options.name) {
-                configOptions.name = options.name;
-            }
+    if (options.configName) {
+      const notFoundConfigNames = [];
 
-            if (typeof options.stats !== 'undefined') {
-                configOptions.stats = options.stats;
-            }
+      config.options = options.configName.map((configName) => {
+        let found;
 
-            if (typeof options.watch !== 'undefined') {
-                configOptions.watch = options.watch;
-            }
+        if (Array.isArray(config.options)) {
+          found = config.options.find((options) => options.name === configName);
+        } else {
+          found = config.options.name === configName ? config.options : undefined;
+        }
 
-            if (typeof options.watchOptionsStdin !== 'undefined') {
-                configOptions.watchOptions = {
-                    ...configOptions.watchOptions,
-                    ...{ stdin: options.watchOptionsStdin },
-                };
-            }
+        if (!found) {
+          notFoundConfigNames.push(configName);
+        }
 
-            return configOptions;
-        };
+        return found;
+      });
 
-        config.options = Array.isArray(config.options)
-            ? config.options.map((options) => processLegacyArguments(options))
-            : processLegacyArguments(config.options);
-
-        // Apply `stats` and `stats.colors` options
-        const applyStatsColors = (configOptions) => {
-            // TODO remove after drop webpack@4
-            const statsForWebpack4 = this.webpack.Stats && this.webpack.Stats.presetToOptions;
-
-            if (statsForWebpack4) {
-                if (typeof configOptions.stats === 'undefined') {
-                    configOptions.stats = {};
-                } else if (typeof configOptions.stats === 'boolean' || typeof configOptions.stats === 'string') {
-                    if (
-                        typeof configOptions.stats === 'string' &&
-                        configOptions.stats !== 'none' &&
-                        configOptions.stats !== 'verbose' &&
-                        configOptions.stats !== 'detailed' &&
-                        configOptions.stats !== 'minimal' &&
-                        configOptions.stats !== 'errors-only' &&
-                        configOptions.stats !== 'errors-warnings'
-                    ) {
-                        return configOptions;
-                    }
-
-                    configOptions.stats = this.webpack.Stats.presetToOptions(configOptions.stats);
-                }
-            } else {
-                if (typeof configOptions.stats === 'undefined') {
-                    configOptions.stats = { preset: 'normal' };
-                } else if (typeof configOptions.stats === 'boolean') {
-                    configOptions.stats = configOptions.stats ? { preset: 'normal' } : { preset: 'none' };
-                } else if (typeof configOptions.stats === 'string') {
-                    configOptions.stats = { preset: configOptions.stats };
-                }
-            }
+      if (notFoundConfigNames.length > 0) {
+        this.logger.error(
+          notFoundConfigNames
+            .map((configName) => `Configuration with the name "${configName}" was not found.`)
+            .join(" "),
+        );
+        process.exit(2);
+      }
+    }
 
-            let colors;
+    if (options.merge) {
+      const merge = await this.tryRequireThenImport("webpack-merge");
 
-            // From arguments
-            if (typeof this.utils.colors.options.changed !== 'undefined') {
-                colors = Boolean(this.utils.colors.options.enabled);
-            }
-            // From stats
-            else if (typeof configOptions.stats.colors !== 'undefined') {
-                colors = configOptions.stats.colors;
-            }
-            // Default
-            else {
-                colors = Boolean(this.utils.colors.options.enabled);
-            }
+      // we can only merge when there are multiple configurations
+      // either by passing multiple configs by flags or passing a
+      // single config exporting an array
+      if (!Array.isArray(config.options) || config.options.length <= 1) {
+        this.logger.error("At least two configurations are required for merge.");
+        process.exit(2);
+      }
 
-            configOptions.stats.colors = colors;
+      const mergedConfigPaths = [];
 
-            return configOptions;
-        };
+      config.options = config.options.reduce((accumulator, options) => {
+        const configPath = config.path.get(options);
+        const mergedOptions = merge(accumulator, options);
 
-        config.options = Array.isArray(config.options)
-            ? config.options.map((options) => applyStatsColors(options))
-            : applyStatsColors(config.options);
+        mergedConfigPaths.push(configPath);
 
-        return config;
+        return mergedOptions;
+      }, {});
+      config.path.set(config.options, mergedConfigPaths);
     }
 
-    async applyCLIPlugin(config, cliOptions) {
-        const addCLIPlugin = (configOptions) => {
-            if (!configOptions.plugins) {
-                configOptions.plugins = [];
-            }
+    return config;
+  }
 
-            const CLIPlugin = require('./plugins/CLIPlugin');
-
-            configOptions.plugins.unshift(
-                new CLIPlugin({
-                    configPath: config.path,
-                    helpfulOutput: !cliOptions.json,
-                    hot: cliOptions.hot,
-                    progress: cliOptions.progress,
-                    prefetch: cliOptions.prefetch,
-                    analyze: cliOptions.analyze,
-                }),
+  async buildConfig(config, options) {
+    const runFunctionOnEachConfig = (options, fn) => {
+      if (Array.isArray(options)) {
+        for (let item of options) {
+          item = fn(item);
+        }
+      } else {
+        options = fn(options);
+      }
+
+      return options;
+    };
+
+    if (options.analyze) {
+      if (!this.checkPackageExists("webpack-bundle-analyzer")) {
+        await this.doInstall("webpack-bundle-analyzer", {
+          preMessage: () => {
+            this.logger.error(
+              `It looks like ${this.colors.yellow("webpack-bundle-analyzer")} is not installed.`,
             );
+          },
+        });
 
-            return configOptions;
-        };
-        config.options = Array.isArray(config.options)
-            ? config.options.map((options) => addCLIPlugin(options))
-            : addCLIPlugin(config.options);
+        this.logger.success(
+          `${this.colors.yellow("webpack-bundle-analyzer")} was installed successfully.`,
+        );
+      }
+    }
+
+    if (typeof options.progress === "string" && options.progress !== "profile") {
+      this.logger.error(
+        `'${options.progress}' is an invalid value for the --progress option. Only 'profile' is allowed.`,
+      );
+      process.exit(2);
+    }
 
-        return config;
+    if (typeof options.hot === "string" && options.hot !== "only") {
+      this.logger.error(
+        `'${options.hot}' is an invalid value for the --hot option. Use 'only' instead.`,
+      );
+      process.exit(2);
     }
 
-    needWatchStdin(compiler) {
-        if (compiler.compilers) {
-            return compiler.compilers.some((compiler) => compiler.options.watchOptions && compiler.options.watchOptions.stdin);
+    const CLIPlugin = await this.tryRequireThenImport("./plugins/CLIPlugin");
+
+    const internalBuildConfig = (item) => {
+      // Output warnings
+      if (
+        item.watch &&
+        options.argv &&
+        options.argv.env &&
+        (options.argv.env["WEBPACK_WATCH"] || options.argv.env["WEBPACK_SERVE"])
+      ) {
+        this.logger.warn(
+          `No need to use the '${
+            options.argv.env["WEBPACK_WATCH"] ? "watch" : "serve"
+          }' command together with '{ watch: true }' configuration, it does not make sense.`,
+        );
+
+        if (options.argv.env["WEBPACK_SERVE"]) {
+          item.watch = false;
         }
+      }
 
-        return compiler.options.watchOptions && compiler.options.watchOptions.stdin;
-    }
+      // Apply options
+      if (this.webpack.cli) {
+        const args = this.getBuiltInOptions()
+          .filter((flag) => flag.group === "core")
+          .reduce((accumulator, flag) => {
+            accumulator[flag.name] = flag;
 
-    isValidationError(error) {
-        // https://github.com/webpack/webpack/blob/master/lib/index.js#L267
-        // https://github.com/webpack/webpack/blob/v4.44.2/lib/webpack.js#L90
-        const ValidationError = this.webpack.ValidationError || this.webpack.WebpackOptionsValidationError;
+            return accumulator;
+          }, {});
 
-        return error instanceof ValidationError || error.name === 'ValidationError';
-    }
+        const values = Object.keys(options).reduce((accumulator, name) => {
+          if (name === "argv") {
+            return accumulator;
+          }
 
-    async createCompiler(options, callback) {
-        this.applyNodeEnv(options);
+          const kebabName = this.toKebabCase(name);
 
-        let config = await this.resolveConfig(options);
+          if (args[kebabName]) {
+            accumulator[kebabName] = options[name];
+          }
 
-        config = await this.applyOptions(config, options);
-        config = await this.applyCLIPlugin(config, options);
+          return accumulator;
+        }, {});
 
-        let compiler;
+        const problems = this.webpack.cli.processArguments(args, item, values);
 
-        try {
-            compiler = this.webpack(
-                config.options,
-                callback
-                    ? (error, stats) => {
-                          if (error && this.isValidationError(error)) {
-                              this.logger.error(error.message);
-                              process.exit(2);
-                          }
-
-                          callback(error, stats);
-                      }
-                    : callback,
-            );
-        } catch (error) {
-            if (this.isValidationError(error)) {
-                this.logger.error(error.message);
-            } else {
-                this.logger.error(error);
-            }
+        if (problems) {
+          const groupBy = (xs, key) => {
+            return xs.reduce((rv, x) => {
+              (rv[x[key]] = rv[x[key]] || []).push(x);
 
-            process.exit(2);
-        }
+              return rv;
+            }, {});
+          };
+          const problemsByPath = groupBy(problems, "path");
+
+          for (const path in problemsByPath) {
+            const problems = problemsByPath[path];
+
+            problems.forEach((problem) => {
+              this.logger.error(
+                `${this.capitalizeFirstLetter(problem.type.replace(/-/g, " "))}${
+                  problem.value ? ` '${problem.value}'` : ""
+                } for the '--${problem.argument}' option${
+                  problem.index ? ` by index '${problem.index}'` : ""
+                }`,
+              );
+
+              if (problem.expected) {
+                this.logger.error(`Expected: '${problem.expected}'`);
+              }
+            });
+          }
 
-        // TODO webpack@4 return Watching and MultiWatching instead Compiler and MultiCompiler, remove this after drop webpack@4
-        if (compiler && compiler.compiler) {
-            compiler = compiler.compiler;
+          process.exit(2);
         }
 
-        return compiler;
-    }
-
-    async buildCommand(options, isWatchCommand) {
-        let compiler;
+        // Setup default cache options
+        if (item.cache && item.cache.type === "filesystem") {
+          const configPath = config.path.get(item);
 
-        const callback = (error, stats) => {
-            if (error) {
-                this.logger.error(error);
-                process.exit(2);
+          if (configPath) {
+            if (!item.cache.buildDependencies) {
+              item.cache.buildDependencies = {};
             }
 
-            if (stats.hasErrors()) {
-                process.exitCode = 1;
+            if (!item.cache.buildDependencies.defaultConfig) {
+              item.cache.buildDependencies.defaultConfig = [];
             }
 
-            if (!compiler) {
-                return;
+            if (Array.isArray(configPath)) {
+              configPath.forEach((oneOfConfigPath) => {
+                item.cache.buildDependencies.defaultConfig.push(oneOfConfigPath);
+              });
+            } else {
+              item.cache.buildDependencies.defaultConfig.push(configPath);
             }
+          }
+        }
+      }
+
+      // Setup legacy logic for webpack@4
+      // TODO respect `--entry-reset` in th next major release
+      // TODO drop in the next major release
+      if (options.entry) {
+        item.entry = options.entry;
+      }
+
+      if (options.outputPath) {
+        item.output = { ...item.output, ...{ path: path.resolve(options.outputPath) } };
+      }
+
+      if (options.target) {
+        item.target = options.target;
+      }
+
+      if (typeof options.devtool !== "undefined") {
+        item.devtool = options.devtool;
+      }
+
+      if (options.name) {
+        item.name = options.name;
+      }
+
+      if (typeof options.stats !== "undefined") {
+        item.stats = options.stats;
+      }
+
+      if (typeof options.watch !== "undefined") {
+        item.watch = options.watch;
+      }
+
+      if (typeof options.watchOptionsStdin !== "undefined") {
+        item.watchOptions = { ...item.watchOptions, ...{ stdin: options.watchOptionsStdin } };
+      }
+
+      if (options.mode) {
+        item.mode = options.mode;
+      }
+
+      // Respect `process.env.NODE_ENV`
+      if (
+        !item.mode &&
+        process.env &&
+        process.env.NODE_ENV &&
+        (process.env.NODE_ENV === "development" ||
+          process.env.NODE_ENV === "production" ||
+          process.env.NODE_ENV === "none")
+      ) {
+        item.mode = process.env.NODE_ENV;
+      }
+
+      // Setup stats
+      // TODO remove after drop webpack@4
+      const statsForWebpack4 = this.webpack.Stats && this.webpack.Stats.presetToOptions;
+
+      if (statsForWebpack4) {
+        if (typeof item.stats === "undefined") {
+          item.stats = {};
+        } else if (typeof item.stats === "boolean") {
+          item.stats = this.webpack.Stats.presetToOptions(item.stats);
+        } else if (
+          typeof item.stats === "string" &&
+          (item.stats === "none" ||
+            item.stats === "verbose" ||
+            item.stats === "detailed" ||
+            item.stats === "normal" ||
+            item.stats === "minimal" ||
+            item.stats === "errors-only" ||
+            item.stats === "errors-warnings")
+        ) {
+          item.stats = this.webpack.Stats.presetToOptions(item.stats);
+        }
+      } else {
+        if (typeof item.stats === "undefined") {
+          item.stats = { preset: "normal" };
+        } else if (typeof item.stats === "boolean") {
+          item.stats = item.stats ? { preset: "normal" } : { preset: "none" };
+        } else if (typeof item.stats === "string") {
+          item.stats = { preset: item.stats };
+        }
+      }
+
+      let colors;
+
+      // From arguments
+      if (typeof this.isColorSupportChanged !== "undefined") {
+        colors = Boolean(this.isColorSupportChanged);
+      }
+      // From stats
+      else if (typeof item.stats.colors !== "undefined") {
+        colors = item.stats.colors;
+      }
+      // Default
+      else {
+        colors = Boolean(this.colors.isColorSupported);
+      }
+
+      // TODO remove after drop webpack v4
+      if (typeof item.stats === "object" && item.stats !== null) {
+        item.stats.colors = colors;
+      }
+
+      // Apply CLI plugin
+      if (!item.plugins) {
+        item.plugins = [];
+      }
+
+      item.plugins.unshift(
+        new CLIPlugin({
+          configPath: config.path.get(item),
+          helpfulOutput: !options.json,
+          hot: options.hot,
+          progress: options.progress,
+          prefetch: options.prefetch,
+          analyze: options.analyze,
+        }),
+      );
+
+      return options;
+    };
+
+    runFunctionOnEachConfig(config.options, internalBuildConfig);
+
+    return config;
+  }
+
+  isValidationError(error) {
+    // https://github.com/webpack/webpack/blob/master/lib/index.js#L267
+    // https://github.com/webpack/webpack/blob/v4.44.2/lib/webpack.js#L90
+    const ValidationError =
+      this.webpack.ValidationError || this.webpack.WebpackOptionsValidationError;
+
+    return error instanceof ValidationError || error.name === "ValidationError";
+  }
+
+  async createCompiler(options, callback) {
+    if (typeof options.nodeEnv === "string") {
+      process.env.NODE_ENV = options.nodeEnv;
+    }
+
+    let config = await this.loadConfig(options);
+    config = await this.buildConfig(config, options);
 
-            const statsOptions = compiler.compilers
-                ? { children: compiler.compilers.map((compiler) => (compiler.options ? compiler.options.stats : undefined)) }
-                : compiler.options
-                ? compiler.options.stats
-                : undefined;
+    let compiler;
 
-            // TODO webpack@4 doesn't support `{ children: [{ colors: true }, { colors: true }] }` for stats
-            const statsForWebpack4 = this.webpack.Stats && this.webpack.Stats.presetToOptions;
+    try {
+      compiler = this.webpack(
+        config.options,
+        callback
+          ? (error, stats) => {
+              if (error && this.isValidationError(error)) {
+                this.logger.error(error.message);
+                process.exit(2);
+              }
 
-            if (compiler.compilers && statsForWebpack4) {
-                statsOptions.colors = statsOptions.children.some((child) => child.colors);
+              callback(error, stats);
             }
+          : callback,
+      );
+    } catch (error) {
+      if (this.isValidationError(error)) {
+        this.logger.error(error.message);
+      } else {
+        this.logger.error(error);
+      }
+
+      process.exit(2);
+    }
 
-            if (options.json) {
-                const { stringifyStream: createJsonStringifyStream } = require('@discoveryjs/json-ext');
-                const handleWriteError = (error) => {
-                    this.logger.error(error);
-                    process.exit(2);
-                };
-
-                if (options.json === true) {
-                    createJsonStringifyStream(stats.toJson(statsOptions))
-                        .on('error', handleWriteError)
-                        .pipe(process.stdout)
-                        .on('error', handleWriteError)
-                        .on('close', () => process.stdout.write('\n'));
-                } else {
-                    createJsonStringifyStream(stats.toJson(statsOptions))
-                        .on('error', handleWriteError)
-                        .pipe(fs.createWriteStream(options.json))
-                        .on('error', handleWriteError)
-                        // Use stderr to logging
-                        .on('close', () =>
-                            process.stderr.write(
-                                `[webpack-cli] ${this.utils.colors.green(`stats are successfully stored as json to ${options.json}`)}\n`,
-                            ),
-                        );
-                }
-            } else {
-                const printedStats = stats.toString(statsOptions);
+    // TODO webpack@4 return Watching and MultiWatching instead Compiler and MultiCompiler, remove this after drop webpack@4
+    if (compiler && compiler.compiler) {
+      compiler = compiler.compiler;
+    }
 
-                // Avoid extra empty line when `stats: 'none'`
-                if (printedStats) {
-                    this.logger.raw(printedStats);
-                }
-            }
-        };
+    return compiler;
+  }
 
-        const env =
-            isWatchCommand || options.watch
-                ? { WEBPACK_WATCH: true, ...options.env }
-                : { WEBPACK_BUNDLE: true, WEBPACK_BUILD: true, ...options.env };
+  needWatchStdin(compiler) {
+    if (compiler.compilers) {
+      return compiler.compilers.some(
+        (compiler) => compiler.options.watchOptions && compiler.options.watchOptions.stdin,
+      );
+    }
 
-        options.argv = { ...options, env };
+    return compiler.options.watchOptions && compiler.options.watchOptions.stdin;
+  }
 
-        if (isWatchCommand) {
-            options.watch = true;
-        }
+  async runWebpack(options, isWatchCommand) {
+    // eslint-disable-next-line prefer-const
+    let compiler;
+    let createJsonStringifyStream;
 
-        compiler = await this.createCompiler(options, callback);
+    if (options.json) {
+      const jsonExt = await this.tryRequireThenImport("@discoveryjs/json-ext");
 
-        if (!compiler) {
-            return;
-        }
+      createJsonStringifyStream = jsonExt.stringifyStream;
+    }
 
-        const isWatch = (compiler) =>
-            compiler.compilers ? compiler.compilers.some((compiler) => compiler.options.watch) : compiler.options.watch;
+    const callback = (error, stats) => {
+      if (error) {
+        this.logger.error(error);
+        process.exit(2);
+      }
+
+      if (stats.hasErrors()) {
+        process.exitCode = 1;
+      }
+
+      if (!compiler) {
+        return;
+      }
+
+      const statsOptions = compiler.compilers
+        ? {
+            children: compiler.compilers.map((compiler) =>
+              compiler.options ? compiler.options.stats : undefined,
+            ),
+          }
+        : compiler.options
+        ? compiler.options.stats
+        : undefined;
+
+      // TODO webpack@4 doesn't support `{ children: [{ colors: true }, { colors: true }] }` for stats
+      const statsForWebpack4 = this.webpack.Stats && this.webpack.Stats.presetToOptions;
+
+      if (compiler.compilers && statsForWebpack4) {
+        statsOptions.colors = statsOptions.children.some((child) => child.colors);
+      }
+
+      if (options.json && createJsonStringifyStream) {
+        const handleWriteError = (error) => {
+          this.logger.error(error);
+          process.exit(2);
+        };
 
-        if (isWatch(compiler) && this.needWatchStdin(compiler)) {
-            process.stdin.on('end', () => {
-                process.exit(0);
+        if (options.json === true) {
+          createJsonStringifyStream(stats.toJson(statsOptions))
+            .on("error", handleWriteError)
+            .pipe(process.stdout)
+            .on("error", handleWriteError)
+            .on("close", () => process.stdout.write("\n"));
+        } else {
+          createJsonStringifyStream(stats.toJson(statsOptions))
+            .on("error", handleWriteError)
+            .pipe(fs.createWriteStream(options.json))
+            .on("error", handleWriteError)
+            // Use stderr to logging
+            .on("close", () => {
+              process.stderr.write(
+                `[webpack-cli] ${this.colors.green(
+                  `stats are successfully stored as json to ${options.json}`,
+                )}\n`,
+              );
             });
-            process.stdin.resume();
         }
+      } else {
+        const printedStats = stats.toString(statsOptions);
+
+        // Avoid extra empty line when `stats: 'none'`
+        if (printedStats) {
+          this.logger.raw(printedStats);
+        }
+      }
+    };
+
+    const env =
+      isWatchCommand || options.watch
+        ? { WEBPACK_WATCH: true, ...options.env }
+        : { WEBPACK_BUNDLE: true, WEBPACK_BUILD: true, ...options.env };
+
+    options.argv = { ...options, env };
+
+    if (isWatchCommand) {
+      options.watch = true;
+    }
+
+    compiler = await this.createCompiler(options, callback);
+
+    if (!compiler) {
+      return;
+    }
+
+    const isWatch = (compiler) =>
+      compiler.compilers
+        ? compiler.compilers.some((compiler) => compiler.options.watch)
+        : compiler.options.watch;
+
+    if (isWatch(compiler) && this.needWatchStdin(compiler)) {
+      process.stdin.on("end", () => {
+        process.exit(0);
+      });
+      process.stdin.resume();
     }
+  }
 }
 
 module.exports = WebpackCLI;