@oclif/core 4.0.0-beta.1 → 4.0.0-beta.10

package/lib/args.d.ts

@@ -21,14 +21,14 @@ import { Arg, ArgDefinition } from './interfaces/parser';
 export declare function custom<T = string, P = Record<string, unknown>>(defaults: Partial<Arg<T, P>>): ArgDefinition<T, P>;
 export declare const boolean: ArgDefinition<boolean, Record<string, unknown>>;
 export declare const integer: ArgDefinition<number, {
-    max?: number | undefined;
-    min?: number | undefined;
+    max?: number;
+    min?: number;
 }>;
 export declare const directory: ArgDefinition<string, {
-    exists?: boolean | undefined;
+    exists?: boolean;
 }>;
 export declare const file: ArgDefinition<string, {
-    exists?: boolean | undefined;
+    exists?: boolean;
 }>;
 /**
  * Initializes a string as a URL. Throws an error

package/lib/cache.d.ts

@@ -1,5 +1,5 @@
 import { Config } from './config/config';
-import { PJSON, Plugin } from './interfaces';
+import { OclifConfiguration, Plugin } from './interfaces';
 type OclifCoreInfo = {
     name: string;
     version: string;
@@ -7,7 +7,7 @@ type OclifCoreInfo = {
 type CacheContents = {
     rootPlugin: Plugin;
     config: Config;
-    exitCodes: PJSON.Plugin['oclif']['exitCodes'];
+    exitCodes: OclifConfiguration['exitCodes'];
     '@oclif/core': OclifCoreInfo;
 };
 type ValueOf<T> = T[keyof T];
@@ -21,7 +21,7 @@ export default class Cache extends Map<keyof CacheContents, ValueOf<CacheContent
     get(key: 'config'): Config | undefined;
     get(key: '@oclif/core'): OclifCoreInfo;
     get(key: 'rootPlugin'): Plugin | undefined;
-    get(key: 'exitCodes'): PJSON.Plugin['oclif']['exitCodes'] | undefined;
+    get(key: 'exitCodes'): OclifConfiguration['exitCodes'] | undefined;
     private getOclifCoreMeta;
 }
 export {};

package/lib/cache.js

@@ -28,7 +28,7 @@ class Cache extends Map {
             try {
                 return {
                     name: '@oclif/core',
-                    version: JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '..', 'package.json'), 'utf8')),
+                    version: JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '..', 'package.json'), 'utf8')).version,
                 };
             }
             catch {

package/lib/command.d.ts

@@ -109,7 +109,7 @@ export declare abstract class Command {
     log(message?: string, ...args: any[]): void;
     protected logJson(json: unknown): void;
     logToStderr(message?: string, ...args: any[]): void;
-    protected parse<F extends FlagOutput, B extends FlagOutput, A extends ArgOutput>(options?: Input<F, B, A>, argv?: string[]): Promise<ParserOutput<F, B, A>>;
+    protected parse<F extends FlagOutput, B extends FlagOutput, A extends ArgOutput>(options?: Input<F, B, A>, argv?: string[]): Promise<ParserOutput<F, A>>;
     protected toErrorJson(err: unknown): any;
     protected toSuccessJson(result: unknown): any;
     warn(input: Error | string): Error | string;
@@ -143,15 +143,15 @@ export declare namespace Command {
      */
     type Cached = {
         [key: string]: unknown;
-        aliasPermutations?: string[];
+        aliasPermutations?: string[] | undefined;
         aliases: string[];
         args: {
             [name: string]: Arg.Cached;
         };
-        deprecateAliases?: boolean;
-        deprecationOptions?: Deprecation;
-        description?: string;
-        examples?: Example[];
+        deprecateAliases?: boolean | undefined;
+        deprecationOptions?: Deprecation | undefined;
+        description?: string | undefined;
+        examples?: Example[] | undefined;
         flags: {
             [name: string]: Flag.Cached;
         };
@@ -159,22 +159,22 @@ export declare namespace Command {
         hidden: boolean;
         hiddenAliases: string[];
         id: string;
-        isESM?: boolean;
-        permutations?: string[];
-        pluginAlias?: string;
-        pluginName?: string;
-        pluginType?: string;
-        relativePath?: string[];
-        state?: 'beta' | 'deprecated' | string;
-        strict?: boolean;
-        summary?: string;
-        type?: string;
-        usage?: string | string[];
+        isESM?: boolean | undefined;
+        permutations?: string[] | undefined;
+        pluginAlias?: string | undefined;
+        pluginName?: string | undefined;
+        pluginType?: string | undefined;
+        relativePath?: string[] | undefined;
+        state?: 'beta' | 'deprecated' | string | undefined;
+        strict?: boolean | undefined;
+        summary?: string | undefined;
+        type?: string | undefined;
+        usage?: string | string[] | undefined;
     };
     type Flag = IFlag<any>;
     namespace Flag {
         type Cached = Omit<Flag, 'input' | 'parse'> & (BooleanFlagProps | OptionFlagProps) & {
-            hasDynamicHelp?: boolean;
+            hasDynamicHelp?: boolean | undefined;
         };
         type Any = Cached | Flag;
     }

package/lib/command.js

@@ -34,11 +34,12 @@ const cache_1 = __importDefault(require("./cache"));
 const config_1 = require("./config");
 const Errors = __importStar(require("./errors"));
 const util_1 = require("./help/util");
+const logger_1 = require("./logger");
 const Parser = __importStar(require("./parser"));
 const aggregate_flags_1 = require("./util/aggregate-flags");
 const ids_1 = require("./util/ids");
 const util_2 = require("./util/util");
-const ux_1 = __importDefault(require("./ux"));
+const ux_1 = require("./ux");
 const pjson = cache_1.default.getInstance().get('@oclif/core');
 /**
  * swallows stdout epipe errors
@@ -123,7 +124,7 @@ class Command {
         this.config = config;
         this.id = this.ctor.id;
         try {
-            this.debug = require('debug')(this.id ? `${this.config.bin}:${this.id}` : this.config.bin);
+            this.debug = (0, logger_1.makeDebug)(this.id ? `${this.config.bin}:${this.id}` : this.config.bin);
         }
         catch {
             this.debug = () => {
@@ -147,6 +148,9 @@ class Command {
             opts = (0, node_url_1.fileURLToPath)(opts);
         }
         const config = await config_1.Config.load(opts || require.main?.filename || __dirname);
+        const cache = cache_1.default.getInstance();
+        if (!cache.has('config'))
+            cache.set('config', config);
         const cmd = new this(argv, config);
         if (!cmd.id) {
             const id = cmd.constructor.name.toLowerCase();
@@ -167,7 +171,7 @@ class Command {
             if (!err.message)
                 throw err;
             try {
-                ux_1.default.action.stop(ansis_1.default.bold.red('!'));
+                ux_1.ux.action.stop(ansis_1.default.bold.red('!'));
             }
             catch { }
             throw err;
@@ -179,22 +183,9 @@ class Command {
     exit(code = 0) {
         Errors.exit(code);
     }
-    async finally(_) {
-        try {
-            const { config } = Errors;
-            if (config.errorLogger)
-                await config.errorLogger.flush();
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
+    async finally(_) { }
     async init() {
         this.debug('init version: %s argv: %o', this.ctor._base, this.argv);
-        if (this.config.debug)
-            Errors.config.debug = true;
-        if (this.config.errlog)
-            Errors.config.errlog = this.config.errlog;
         const g = global;
         g['http-call'] = g['http-call'] || {};
         g['http-call'].userAgent = this.config.userAgent;
@@ -223,16 +214,16 @@ class Command {
     log(message = '', ...args) {
         if (!this.jsonEnabled()) {
             message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
-            ux_1.default.stdout(message, ...args);
+            ux_1.ux.stdout(message, ...args);
         }
     }
     logJson(json) {
-        ux_1.default.stdout(ux_1.default.colorizeJson(json, { pretty: true, theme: this.config.theme?.json }));
+        ux_1.ux.stdout(ux_1.ux.colorizeJson(json, { pretty: true, theme: this.config.theme?.json }));
     }
     logToStderr(message = '', ...args) {
         if (!this.jsonEnabled()) {
             message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
-            ux_1.default.stderr(message, ...args);
+            ux_1.ux.stderr(message, ...args);
         }
     }
     async parse(options, argv = this.argv) {

package/lib/config/config.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '../command';
-import { Hook, Hooks, PJSON, Topic } from '../interfaces';
+import { Hook, Hooks, OclifConfiguration, PJSON, S3Templates, Topic, UserPJSON } from '../interfaces';
 import { ArchTypes, Config as IConfig, LoadOptions, PlatformTypes, VersionDetails } from '../interfaces/config';
 import { Plugin as IPlugin, Options } from '../interfaces/plugin';
 import { Theme } from '../interfaces/theme';
@@ -7,31 +7,29 @@ export declare class Config implements IConfig {
     options: Options;
     arch: ArchTypes;
     bin: string;
-    binAliases?: string[];
-    binPath?: string;
+    binAliases?: string[] | undefined;
+    binPath?: string | undefined;
     cacheDir: string;
     channel: string;
     configDir: string;
     dataDir: string;
-    debug: number;
     dirname: string;
-    errlog: string;
     flexibleTaxonomy: boolean;
     home: string;
     isSingleCommandCLI: boolean;
     name: string;
-    npmRegistry?: string;
-    nsisCustomization?: string;
-    pjson: PJSON.CLI;
+    npmRegistry?: string | undefined;
+    nsisCustomization?: string | undefined;
+    pjson: PJSON;
     platform: PlatformTypes;
     plugins: Map<string, IPlugin>;
     root: string;
     shell: string;
-    theme?: Theme;
+    theme?: Theme | undefined;
     topicSeparator: ' ' | ':';
-    updateConfig: NonNullable<PJSON.CLI['oclif']['update']>;
+    updateConfig: NonNullable<OclifConfiguration['update']>;
     userAgent: string;
-    userPJSON?: PJSON.User;
+    userPJSON?: UserPJSON | undefined;
     valid: boolean;
     version: string;
     protected warned: boolean;
@@ -98,7 +96,7 @@ export declare class Config implements IConfig {
     protected macosCacheDir(): string | undefined;
     runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable | null): Promise<T>;
     runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number, captureErrors?: boolean): Promise<Hook.Result<Hooks[T]['return']>>;
-    s3Key(type: keyof PJSON.S3.Templates, ext?: '.tar.gz' | '.tar.xz' | IConfig.s3Key.Options, options?: IConfig.s3Key.Options): string;
+    s3Key(type: keyof S3Templates, ext?: '.tar.gz' | '.tar.xz' | IConfig.s3Key.Options, options?: IConfig.s3Key.Options): string;
     s3Url(key: string): string;
     scopedEnvVar(k: string): string | undefined;
     /**
@@ -114,36 +112,11 @@ export declare class Config implements IConfig {
      */
     scopedEnvVarKeys(k: string): string[];
     scopedEnvVarTrue(k: string): boolean;
-    protected warn(err: {
-        detail: string;
-        name: string;
-    } | Error | string, scope?: string): void;
     protected windowsHome(): string | undefined;
     protected windowsHomedriveHome(): string | undefined;
     protected windowsUserprofileHome(): string | undefined;
-    protected _debug(): number;
     protected _shell(): string;
     private buildS3Config;
-    /**
-     * This method is responsible for locating the correct plugin to use for a named command id
-     * It searches the {Config} registered commands to match either the raw command id or the command alias
-     * It is possible that more than one command will be found. This is due the ability of two distinct plugins to
-     * create the same command or command alias.
-     *
-     * In the case of more than one found command, the function will select the command based on the order in which
-     * the plugin is included in the package.json `oclif.plugins` list. The command that occurs first in the list
-     * is selected as the command to run.
-     *
-     * Commands can also be present from either an install or a link. When a command is one of these and a core plugin
-     * is present, this function defers to the core plugin.
-     *
-     * If there is not a core plugin command present, this function will return the first
-     * plugin as discovered (will not change the order)
-     *
-     * @param commands commands to determine the priority of
-     * @returns command instance {Command.Loadable} or undefined
-     */
-    private determinePriority;
     private getCmdLookupId;
     private getTopicLookupId;
     /**
@@ -159,4 +132,6 @@ export declare class Config implements IConfig {
     private isJitPluginCommand;
     private loadCommands;
     private loadTopics;
+    private maybeAdjustDebugSetting;
+    private warn;
 }

package/lib/config/config.js

@@ -35,22 +35,32 @@ const node_url_1 = require("node:url");
 const cache_1 = __importDefault(require("../cache"));
 const errors_1 = require("../errors");
 const util_1 = require("../help/util");
+const logger_1 = require("../logger");
 const module_loader_1 = require("../module-loader");
 const performance_1 = require("../performance");
 const settings_1 = require("../settings");
+const determine_priority_1 = require("../util/determine-priority");
 const fs_1 = require("../util/fs");
 const os_1 = require("../util/os");
 const util_2 = require("../util/util");
-const ux_1 = __importDefault(require("../ux"));
+const ux_1 = require("../ux");
 const theme_1 = require("../ux/theme");
 const plugin_loader_1 = __importDefault(require("./plugin-loader"));
 const ts_path_1 = require("./ts-path");
 const util_3 = require("./util");
-// eslint-disable-next-line new-cap
-const debug = (0, util_3.Debug)();
+const debug = (0, util_3.makeDebug)();
 const _pjson = cache_1.default.getInstance().get('@oclif/core');
 const BASE = `${_pjson.name}@${_pjson.version}`;
 const ROOT_ONLY_HOOKS = new Set(['preparse']);
+function displayWarnings() {
+    if (process.listenerCount('warning') > 1)
+        return;
+    process.on('warning', (warning) => {
+        console.error(warning.stack);
+        if (warning.detail)
+            console.error(warning.detail);
+    });
+}
 function channelFromVersion(version) {
     const m = version.match(/[^-]+(?:-([^.]+))?/);
     return (m && m[1]) || 'stable';
@@ -94,9 +104,7 @@ class Config {
     channel;
     configDir;
     dataDir;
-    debug = 0;
     dirname;
-    errlog;
     flexibleTaxonomy;
     home;
     isSingleCommandCLI = false;
@@ -129,6 +137,7 @@ class Config {
         this.options = options;
     }
     static async load(opts = module.filename || __dirname) {
+        (0, logger_1.setLogger)(opts);
         // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
         if (typeof opts === 'string' && opts.startsWith('file://')) {
             opts = (0, node_url_1.fileURLToPath)(opts);
@@ -263,6 +272,9 @@ class Config {
     async load() {
         settings_1.settings.performanceEnabled =
             (settings_1.settings.performanceEnabled === undefined ? this.options.enablePerf : settings_1.settings.performanceEnabled) ?? false;
+        if (settings_1.settings.debug)
+            displayWarnings();
+        (0, logger_1.setLogger)(this.options);
         const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'config.load');
         this.pluginLoader = new plugin_loader_1.default({ plugins: this.options.plugins, root: this.options.root });
         this.rootPlugin = await this.pluginLoader.loadRoot({ pjson: this.options.pjson });
@@ -295,12 +307,10 @@ class Config {
             this.dirname = this.dirname.replace('/', '\\');
         this.userAgent = `${this.name}/${this.version} ${this.platform}-${this.arch} node-${process.version}`;
         this.shell = this._shell();
-        this.debug = this._debug();
         this.home = process.env.HOME || (this.windows && this.windowsHome()) || (0, os_1.getHomeDir)() || (0, node_os_1.tmpdir)();
         this.cacheDir = this.scopedEnvVar('CACHE_DIR') || this.macosCacheDir() || this.dir('cache');
         this.configDir = this.scopedEnvVar('CONFIG_DIR') || this.dir('config');
         this.dataDir = this.scopedEnvVar('DATA_DIR') || this.dir('data');
-        this.errlog = (0, node_path_1.join)(this.cacheDir, 'error.log');
         this.binPath = this.scopedEnvVar('BINPATH');
         this.npmRegistry = this.scopedEnvVar('NPM_REGISTRY') || this.pjson.oclif.npmRegistry;
         this.theme = await this.loadTheme();
@@ -309,10 +319,10 @@ class Config {
             node: this.pjson.oclif.update?.node ?? {},
             s3: this.buildS3Config(),
         };
-        this.isSingleCommandCLI = Boolean(this.pjson.oclif.default ||
-            (typeof this.pjson.oclif.commands !== 'string' &&
-                this.pjson.oclif.commands?.strategy === 'single' &&
-                this.pjson.oclif.commands?.target));
+        this.isSingleCommandCLI = Boolean(typeof this.pjson.oclif.commands !== 'string' &&
+            this.pjson.oclif.commands?.strategy === 'single' &&
+            this.pjson.oclif.commands?.target);
+        this.maybeAdjustDebugSetting();
         await this.loadPluginsAndCommands();
         debug('config done');
         marker?.addDetails({
@@ -348,12 +358,17 @@ class Config {
     async loadTheme() {
         if (this.scopedEnvVarTrue('DISABLE_THEME'))
             return;
-        const defaultThemeFile = this.pjson.oclif.theme
-            ? (0, node_path_1.resolve)(this.root, this.pjson.oclif.theme)
-            : this.pjson.oclif.theme;
         const userThemeFile = (0, node_path_1.resolve)(this.configDir, 'theme.json');
+        const getDefaultTheme = async () => {
+            if (!this.pjson.oclif.theme)
+                return;
+            if (typeof this.pjson.oclif.theme === 'string') {
+                return (0, fs_1.safeReadJson)((0, node_path_1.resolve)(this.root, this.pjson.oclif.theme));
+            }
+            return this.pjson.oclif.theme;
+        };
         const [defaultTheme, userTheme] = await Promise.all([
-            defaultThemeFile ? await (0, fs_1.safeReadJson)(defaultThemeFile) : undefined,
+            await getDefaultTheme(),
             await (0, fs_1.safeReadJson)(userThemeFile),
         ]);
         // Merge the default theme with the user theme, giving the user theme precedence.
@@ -447,7 +462,7 @@ class Config {
         };
         const plugins = ROOT_ONLY_HOOKS.has(event) ? [this.rootPlugin] : [...this.plugins.values()];
         const promises = plugins.map(async (p) => {
-            const debug = require('debug')([this.bin, p.name, 'hooks', event].join(':'));
+            const debug = (0, logger_1.makeDebug)([p.name, 'hooks', event].join(':'));
             const context = {
                 config: this,
                 debug,
@@ -458,7 +473,7 @@ class Config {
                     (0, errors_1.exit)(code);
                 },
                 log(message, ...args) {
-                    ux_1.default.stdout(message, ...args);
+                    ux_1.ux.stdout(message, ...args);
                 },
                 warn(message) {
                     (0, errors_1.warn)(message);
@@ -518,7 +533,7 @@ class Config {
             options = ext;
         else if (ext)
             options.ext = ext;
-        const template = this.updateConfig.s3.templates[options.platform ? 'target' : 'vanilla'][type] ?? '';
+        const template = this.updateConfig.s3?.templates?.[options.platform ? 'target' : 'vanilla'][type] ?? '';
         return ejs.render(template, { ...this, ...options });
     }
     s3Url(key) {
@@ -557,40 +572,6 @@ class Config {
         const v = this.scopedEnvVar(k);
         return v === '1' || v === 'true';
     }
-    warn(err, scope) {
-        if (this.warned)
-            return;
-        if (typeof err === 'string') {
-            process.emitWarning(err);
-            return;
-        }
-        if (err instanceof Error) {
-            const modifiedErr = err;
-            modifiedErr.name = `${err.name} Plugin: ${this.name}`;
-            modifiedErr.detail = (0, util_2.compact)([
-                err.detail,
-                `module: ${this._base}`,
-                scope && `task: ${scope}`,
-                `plugin: ${this.name}`,
-                `root: ${this.root}`,
-                'See more details with DEBUG=*',
-            ]).join('\n');
-            process.emitWarning(err);
-            return;
-        }
-        // err is an object
-        process.emitWarning('Config.warn expected either a string or Error, but instead received an object');
-        err.name = `${err.name} Plugin: ${this.name}`;
-        err.detail = (0, util_2.compact)([
-            err.detail,
-            `module: ${this._base}`,
-            scope && `task: ${scope}`,
-            `plugin: ${this.name}`,
-            `root: ${this.root}`,
-            'See more details with DEBUG=*',
-        ]).join('\n');
-        process.emitWarning(JSON.stringify(err));
-    }
     windowsHome() {
         return this.windowsHomedriveHome() || this.windowsUserprofileHome();
     }
@@ -600,17 +581,6 @@ class Config {
     windowsUserprofileHome() {
         return process.env.USERPROFILE;
     }
-    _debug() {
-        if (this.scopedEnvVarTrue('DEBUG'))
-            return 1;
-        try {
-            const { enabled } = require('debug')(this.bin);
-            if (enabled)
-                return 1;
-        }
-        catch { }
-        return 0;
-    }
     _shell() {
         let shellPath;
         const { COMSPEC } = process.env;
@@ -653,58 +623,6 @@ class Config {
             templates,
         };
     }
-    /**
-     * This method is responsible for locating the correct plugin to use for a named command id
-     * It searches the {Config} registered commands to match either the raw command id or the command alias
-     * It is possible that more than one command will be found. This is due the ability of two distinct plugins to
-     * create the same command or command alias.
-     *
-     * In the case of more than one found command, the function will select the command based on the order in which
-     * the plugin is included in the package.json `oclif.plugins` list. The command that occurs first in the list
-     * is selected as the command to run.
-     *
-     * Commands can also be present from either an install or a link. When a command is one of these and a core plugin
-     * is present, this function defers to the core plugin.
-     *
-     * If there is not a core plugin command present, this function will return the first
-     * plugin as discovered (will not change the order)
-     *
-     * @param commands commands to determine the priority of
-     * @returns command instance {Command.Loadable} or undefined
-     */
-    determinePriority(commands) {
-        const oclifPlugins = this.pjson.oclif?.plugins ?? [];
-        const commandPlugins = commands.sort((a, b) => {
-            const pluginAliasA = a.pluginAlias ?? 'A-Cannot-Find-This';
-            const pluginAliasB = b.pluginAlias ?? 'B-Cannot-Find-This';
-            const aIndex = oclifPlugins.indexOf(pluginAliasA);
-            const bIndex = oclifPlugins.indexOf(pluginAliasB);
-            // When both plugin types are 'core' plugins sort based on index
-            if (a.pluginType === 'core' && b.pluginType === 'core') {
-                // If b appears first in the pjson.plugins sort it first
-                return aIndex - bIndex;
-            }
-            // if b is a core plugin and a is not sort b first
-            if (b.pluginType === 'core' && a.pluginType !== 'core') {
-                return 1;
-            }
-            // if a is a core plugin and b is not sort a first
-            if (a.pluginType === 'core' && b.pluginType !== 'core') {
-                return -1;
-            }
-            // if a is a jit plugin and b is not sort b first
-            if (a.pluginType === 'jit' && b.pluginType !== 'jit') {
-                return 1;
-            }
-            // if b is a jit plugin and a is not sort a first
-            if (b.pluginType === 'jit' && a.pluginType !== 'jit') {
-                return -1;
-            }
-            // neither plugin is core, so do not change the order
-            return 0;
-        });
-        return commandPlugins[0];
-    }
     getCmdLookupId(id) {
         if (this._commands.has(id))
             return id;
@@ -732,7 +650,7 @@ class Config {
         for (const plugin of plugins) {
             this.plugins.set(plugin.name, plugin);
             // Delete all commands from the legacy plugin so that we can re-add them.
-            // This is necessary because this.determinePriority will pick the initial
+            // This is necessary because determinePriority will pick the initial
             // command that was added, which won't have been converted by PluginLegacy yet.
             for (const cmd of plugin.commands ?? []) {
                 this._commands.delete(cmd.id);
@@ -753,7 +671,10 @@ class Config {
         for (const command of plugin.commands) {
             // set canonical command id
             if (this._commands.has(command.id)) {
-                const prioritizedCommand = this.determinePriority([this._commands.get(command.id), command]);
+                const prioritizedCommand = (0, determine_priority_1.determinePriority)(this.pjson.oclif.plugins ?? [], [
+                    this._commands.get(command.id),
+                    command,
+                ]);
                 this._commands.set(prioritizedCommand.id, prioritizedCommand);
             }
             else {
@@ -770,7 +691,10 @@ class Config {
             }
             const handleAlias = (alias, hidden = false) => {
                 if (this._commands.has(alias)) {
-                    const prioritizedCommand = this.determinePriority([this._commands.get(alias), command]);
+                    const prioritizedCommand = (0, determine_priority_1.determinePriority)(this.pjson.oclif.plugins ?? [], [
+                        this._commands.get(alias),
+                        command,
+                    ]);
                     this._commands.set(alias, { ...prioritizedCommand, id: alias });
                 }
                 else {
@@ -828,5 +752,45 @@ class Config {
         }
         marker?.stop();
     }
+    maybeAdjustDebugSetting() {
+        if (this.scopedEnvVarTrue('DEBUG')) {
+            settings_1.settings.debug = true;
+            displayWarnings();
+        }
+    }
+    warn(err, scope) {
+        if (this.warned)
+            return;
+        if (typeof err === 'string') {
+            process.emitWarning(err);
+            return;
+        }
+        if (err instanceof Error) {
+            const modifiedErr = err;
+            modifiedErr.name = `${err.name} Plugin: ${this.name}`;
+            modifiedErr.detail = (0, util_2.compact)([
+                err.detail,
+                `module: ${this._base}`,
+                scope && `task: ${scope}`,
+                `plugin: ${this.name}`,
+                `root: ${this.root}`,
+                'See more details with DEBUG=*',
+            ]).join('\n');
+            process.emitWarning(err);
+            return;
+        }
+        // err is an object
+        process.emitWarning('Config.warn expected either a string or Error, but instead received an object');
+        err.name = `${err.name} Plugin: ${this.name}`;
+        err.detail = (0, util_2.compact)([
+            err.detail,
+            `module: ${this._base}`,
+            scope && `task: ${scope}`,
+            `plugin: ${this.name}`,
+            `root: ${this.root}`,
+            'See more details with DEBUG=*',
+        ]).join('\n');
+        process.emitWarning(JSON.stringify(err));
+    }
 }
 exports.Config = Config;

package/lib/config/plugin-loader.d.ts

@@ -1,20 +1,20 @@
 import { PJSON } from '../interfaces';
 import { Plugin as IPlugin } from '../interfaces/plugin';
 type PluginLoaderOptions = {
-    plugins?: IPlugin[] | PluginsMap;
+    plugins?: IPlugin[] | PluginsMap | undefined;
     root: string;
 };
 type LoadOpts = {
     dataDir: string;
-    devPlugins?: boolean;
-    force?: boolean;
+    devPlugins?: boolean | undefined;
+    force?: boolean | undefined;
     rootPlugin: IPlugin;
-    userPlugins?: boolean;
+    userPlugins?: boolean | undefined;
     pluginAdditions?: {
         core?: string[];
         dev?: string[];
         path?: string;
-    };
+    } | undefined;
 };
 type PluginsMap = Map<string, IPlugin>;
 export default class PluginLoader {
@@ -28,7 +28,7 @@ export default class PluginLoader {
         plugins: PluginsMap;
     }>;
     loadRoot({ pjson }: {
-        pjson?: PJSON.Plugin;
+        pjson?: PJSON | undefined;
     }): Promise<IPlugin>;
     private loadCorePlugins;
     private loadDevPlugins;