@oclif/core 3.26.6 → 4.0.0-beta.10

package/lib/interfaces/theme.d.ts

@@ -1,21 +1,32 @@
-export declare const STANDARD_CHALK: readonly ["white", "black", "blue", "yellow", "green", "red", "magenta", "cyan", "gray", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright", "bgBlack", "bgRed", "bgGreen", "bgYellow", "bgBlue", "bgMagenta", "bgCyan", "bgWhite", "bgGray", "bgBlackBright", "bgRedBright", "bgGreenBright", "bgYellowBright", "bgBlueBright", "bgMagentaBright", "bgCyanBright", "bgWhiteBright", "bold", "underline", "dim", "italic", "strikethrough"];
-export type StandardChalk = (typeof STANDARD_CHALK)[number];
-export declare const THEME_KEYS: readonly ["alias", "bin", "command", "commandSummary", "dollarSign", "flag", "flagDefaultValue", "flagOptions", "flagRequired", "flagSeparator", "sectionDescription", "sectionHeader", "topic", "version"];
-export type ThemeKey = (typeof THEME_KEYS)[number];
+export declare const STANDARD_ANSI: readonly ["white", "black", "blue", "yellow", "green", "red", "magenta", "cyan", "gray", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright", "bgBlack", "bgRed", "bgGreen", "bgYellow", "bgBlue", "bgMagenta", "bgCyan", "bgWhite", "bgGray", "bgBlackBright", "bgRedBright", "bgGreenBright", "bgYellowBright", "bgBlueBright", "bgMagentaBright", "bgCyanBright", "bgWhiteBright", "bold", "underline", "dim", "italic", "strikethrough"];
+export type StandardAnsi = (typeof STANDARD_ANSI)[number];
+export type JsonTheme = {
+    brace?: string | StandardAnsi;
+    bracket?: string | StandardAnsi;
+    colon?: string | StandardAnsi;
+    comma?: string | StandardAnsi;
+    key?: string | StandardAnsi;
+    string?: string | StandardAnsi;
+    number?: string | StandardAnsi;
+    boolean?: string | StandardAnsi;
+    null?: string | StandardAnsi;
+};
 export type Theme = {
-    [key: string | ThemeKey]: string | StandardChalk | undefined;
-    alias?: string | StandardChalk;
-    bin?: string | StandardChalk;
-    command?: string | StandardChalk;
-    commandSummary?: string | StandardChalk;
-    dollarSign?: string | StandardChalk;
-    flag?: string | StandardChalk;
-    flagDefaultValue?: string | StandardChalk;
-    flagOptions?: string | StandardChalk;
-    flagRequired?: string | StandardChalk;
-    flagSeparator?: string | StandardChalk;
-    sectionDescription?: string | StandardChalk;
-    sectionHeader?: string | StandardChalk;
-    topic?: string | StandardChalk;
-    version?: string | StandardChalk;
+    [key: string]: string | StandardAnsi | Theme | undefined;
+    alias?: string | StandardAnsi;
+    bin?: string | StandardAnsi;
+    command?: string | StandardAnsi;
+    commandSummary?: string | StandardAnsi;
+    dollarSign?: string | StandardAnsi;
+    flag?: string | StandardAnsi;
+    flagDefaultValue?: string | StandardAnsi;
+    flagOptions?: string | StandardAnsi;
+    flagRequired?: string | StandardAnsi;
+    flagSeparator?: string | StandardAnsi;
+    json?: JsonTheme;
+    sectionDescription?: string | StandardAnsi;
+    sectionHeader?: string | StandardAnsi;
+    spinner?: string | StandardAnsi;
+    topic?: string | StandardAnsi;
+    version?: string | StandardAnsi;
 };

package/lib/interfaces/theme.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.THEME_KEYS = exports.STANDARD_CHALK = void 0;
-// chalk doesn't export a list of standard colors, so we have to supply our own
-exports.STANDARD_CHALK = [
+exports.STANDARD_ANSI = void 0;
+exports.STANDARD_ANSI = [
     'white',
     'black',
     'blue',
@@ -43,19 +42,3 @@ exports.STANDARD_CHALK = [
     'italic',
     'strikethrough',
 ];
-exports.THEME_KEYS = [
-    'alias',
-    'bin',
-    'command',
-    'commandSummary',
-    'dollarSign',
-    'flag',
-    'flagDefaultValue',
-    'flagOptions',
-    'flagRequired',
-    'flagSeparator',
-    'sectionDescription',
-    'sectionHeader',
-    'topic',
-    'version',
-];

package/lib/interfaces/topic.d.ts

@@ -1,5 +1,5 @@
 export interface Topic {
-    description?: string;
-    hidden?: boolean;
+    description?: string | undefined;
+    hidden?: boolean | undefined;
     name: string;
 }

package/lib/logger.d.ts

@@ -0,0 +1,14 @@
+import { LoadOptions } from './interfaces/config';
+import { Logger } from './interfaces/logger';
+/**
+ * Returns a logger instance for the given namespace.
+ * If a namespace is provided, a child logger is returned.
+ * If no namespace is provided, the root logger is returned.
+ */
+export declare function getLogger(namespace?: string): Logger;
+/**
+ * Convenience function to create a debug function for a specific namespace
+ */
+export declare function makeDebug(namespace: string): Logger['debug'];
+export declare function setLogger(loadOptions: LoadOptions): void;
+export declare function clearLoggers(): void;

package/lib/logger.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearLoggers = exports.setLogger = exports.makeDebug = exports.getLogger = void 0;
+const debug_1 = __importDefault(require("debug"));
+const OCLIF_NS = 'oclif';
+function makeLogger(namespace = OCLIF_NS) {
+    const debug = (0, debug_1.default)(namespace);
+    return {
+        child: (ns, delimiter) => makeLogger(`${namespace}${delimiter ?? ':'}${ns}`),
+        debug,
+        error: (formatter, ...args) => makeLogger(`${namespace}:error`).debug(formatter, ...args),
+        info: debug,
+        namespace,
+        trace: debug,
+        warn: debug,
+    };
+}
+/**
+ * Cache of logger instances. This is used to prevent creating multiple logger instances for the same namespace.
+ *
+ * The root logger is stored under the 'root' key as well as it's namespace.
+ */
+const cachedLoggers = new Map();
+/**
+ * Returns a logger instance for the given namespace.
+ * If a namespace is provided, a child logger is returned.
+ * If no namespace is provided, the root logger is returned.
+ */
+function getLogger(namespace) {
+    let rootLogger = cachedLoggers.get('root');
+    if (!rootLogger) {
+        set(makeLogger(OCLIF_NS));
+    }
+    rootLogger = cachedLoggers.get('root');
+    if (namespace) {
+        const cachedLogger = cachedLoggers.get(namespace);
+        if (cachedLogger)
+            return cachedLogger;
+        const logger = rootLogger.child(namespace);
+        cachedLoggers.set(namespace, logger);
+        return logger;
+    }
+    return rootLogger;
+}
+exports.getLogger = getLogger;
+function ensureItMatchesInterface(newLogger) {
+    return (typeof newLogger.child === 'function' &&
+        typeof newLogger.debug === 'function' &&
+        typeof newLogger.error === 'function' &&
+        typeof newLogger.info === 'function' &&
+        typeof newLogger.trace === 'function' &&
+        typeof newLogger.warn === 'function' &&
+        typeof newLogger.namespace === 'string');
+}
+function set(newLogger) {
+    if (cachedLoggers.has(newLogger.namespace))
+        return;
+    if (cachedLoggers.has('root'))
+        return;
+    if (ensureItMatchesInterface(newLogger)) {
+        cachedLoggers.set(newLogger.namespace, newLogger);
+        cachedLoggers.set('root', newLogger);
+    }
+    else {
+        process.emitWarning('Logger does not match the Logger interface. Using default logger.');
+    }
+}
+/**
+ * Convenience function to create a debug function for a specific namespace
+ */
+function makeDebug(namespace) {
+    return (formatter, ...args) => getLogger(namespace).debug(formatter, ...args);
+}
+exports.makeDebug = makeDebug;
+function setLogger(loadOptions) {
+    if (loadOptions && typeof loadOptions !== 'string' && 'logger' in loadOptions && loadOptions.logger) {
+        set(loadOptions.logger);
+    }
+    else {
+        set(makeLogger(OCLIF_NS));
+    }
+}
+exports.setLogger = setLogger;
+function clearLoggers() {
+    cachedLoggers.clear();
+}
+exports.clearLoggers = clearLoggers;

package/lib/main.js

@@ -6,12 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = exports.versionAddition = exports.helpAddition = void 0;
 const node_url_1 = require("node:url");
 const cache_1 = __importDefault(require("./cache"));
-const cli_ux_1 = require("./cli-ux");
 const config_1 = require("./config");
 const help_1 = require("./help");
+const logger_1 = require("./logger");
 const performance_1 = require("./performance");
 const symbols_1 = require("./symbols");
-const debug = require('debug')('oclif:main');
+const ux_1 = require("./ux");
 const helpAddition = (argv, config) => {
     if (argv.length === 0 && !config.isSingleCommandCLI)
         return true;
@@ -48,6 +48,8 @@ async function run(argv, options) {
         const help = new Help(config, config.pjson.oclif.helpOptions ?? config.pjson.helpOptions);
         await help.showHelp(argv);
     };
+    (0, logger_1.setLogger)(options);
+    const { debug } = (0, logger_1.getLogger)('main');
     debug(`process.execPath: ${process.execPath}`);
     debug(`process.execArgv: ${process.execArgv}`);
     debug('process.argv: %O', process.argv);
@@ -67,7 +69,7 @@ async function run(argv, options) {
     await config.runHook('init', { argv: argvSlice, id });
     // display version if applicable
     if ((0, exports.versionAddition)(argv, config)) {
-        cli_ux_1.ux.log(config.userAgent);
+        ux_1.ux.stdout(config.userAgent);
         await collectPerf();
         return;
     }

package/lib/parser/errors.d.ts

@@ -3,7 +3,7 @@ import { Arg, ArgInput, CLIParseErrorOptions, OptionFlag } from '../interfaces/p
 export { CLIError } from '../errors';
 export type Validation = {
     name: string;
-    reason?: string;
+    reason?: string | undefined;
     status: 'failed' | 'success';
     validationFn: string;
 };

package/lib/parser/errors.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
-const chalk_1 = __importDefault(require("chalk"));
+const ansis_1 = __importDefault(require("ansis"));
 const cache_1 = __importDefault(require("../cache"));
-const list_1 = require("../cli-ux/list");
 const errors_1 = require("../errors");
 const util_1 = require("../util/util");
+const list_1 = __importDefault(require("../ux/list"));
 var errors_2 = require("../errors");
 Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
 class CLIParseError extends errors_1.CLIError {
@@ -27,7 +27,7 @@ class InvalidArgsSpecError extends CLIParseError {
         let message = 'Invalid argument spec';
         const namedArgs = Object.values(args).filter((a) => a.name);
         if (namedArgs.length > 0) {
-            const list = (0, list_1.renderList)(namedArgs.map((a) => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
+            const list = (0, list_1.default)(namedArgs.map((a) => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
             message += `:\n${list}`;
         }
         super({ exit: cache_1.default.getInstance().get('exitCodes')?.invalidArgsSpec ?? exit, message, parse });
@@ -41,7 +41,7 @@ class RequiredArgsError extends CLIParseError {
         let message = `Missing ${args.length} required arg${args.length === 1 ? '' : 's'}`;
         const namedArgs = args.filter((a) => a.name);
         if (namedArgs.length > 0) {
-            const list = (0, list_1.renderList)(namedArgs.map((a) => {
+            const list = (0, list_1.default)(namedArgs.map((a) => {
                 const description = a.options ? `(${a.options.join('|')}) ${a.description}` : a.description;
                 return [a.name, description];
             }));
@@ -97,7 +97,7 @@ class FailedFlagValidationError extends CLIParseError {
         const reasons = failed.map((r) => r.reason);
         const deduped = (0, util_1.uniq)(reasons);
         const errString = deduped.length === 1 ? 'error' : 'errors';
-        const message = `The following ${errString} occurred:\n  ${chalk_1.default.dim(deduped.join('\n  '))}`;
+        const message = `The following ${errString} occurred:\n  ${ansis_1.default.dim(deduped.join('\n  '))}`;
         super({ exit: cache_1.default.getInstance().get('exitCodes')?.failedFlagValidation ?? exit, message, parse });
     }
 }

package/lib/parser/help.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flagUsages = exports.flagUsage = void 0;
-const chalk_1 = __importDefault(require("chalk"));
+const ansis_1 = __importDefault(require("ansis"));
 const util_1 = require("../util/util");
 function flagUsage(flag, options = {}) {
     const label = [];
@@ -21,7 +21,7 @@ function flagUsage(flag, options = {}) {
     let description = flag.summary || flag.description || '';
     if (options.displayRequired && flag.required)
         description = `(required) ${description}`;
-    description = description ? chalk_1.default.dim(description) : undefined;
+    description = description ? ansis_1.default.dim(description) : undefined;
     return [` ${label.join(',').trim()}${usage}`, description];
 }
 exports.flagUsage = flagUsage;

package/lib/parser/parse.js

@@ -7,13 +7,14 @@ exports.Parser = exports.readStdin = void 0;
 /* eslint-disable no-await-in-loop */
 const node_readline_1 = require("node:readline");
 const cache_1 = __importDefault(require("../cache"));
+const logger_1 = require("../logger");
 const util_1 = require("../util/util");
 const errors_1 = require("./errors");
 let debug;
 try {
     debug =
         process.env.CLI_FLAGS_DEBUG === '1'
-            ? require('debug')('../parser')
+            ? (0, logger_1.makeDebug)('parser')
             : () => {
                 // noop
             };

package/lib/performance.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Performance = exports.OCLIF_MARKER_OWNER = void 0;
 const node_perf_hooks_1 = require("node:perf_hooks");
+const logger_1 = require("./logger");
 const settings_1 = require("./settings");
 exports.OCLIF_MARKER_OWNER = '@oclif/core';
 class Marker {
@@ -143,7 +144,7 @@ class Performance {
     static debug() {
         if (!Performance.enabled)
             return;
-        const oclifDebug = require('debug')('oclif-perf');
+        const oclifDebug = (0, logger_1.makeDebug)('perf');
         const processUpTime = (process.uptime() * 1000).toFixed(4);
         oclifDebug('Process Uptime: %sms', processUpTime);
         oclifDebug('Oclif Time: %sms', Performance.oclifPerf['oclif.runMs'].toFixed(4));
@@ -176,7 +177,7 @@ class Performance {
         if (Performance.oclifPerf['oclif.configLoadMs'] > Performance.oclifPerf['oclif.runMs']) {
             oclifDebug('! Config load time is greater than total oclif time. This might mean that Config was instantiated before oclif was run.');
         }
-        const nonCoreDebug = require('debug')('non-oclif-perf');
+        const nonCoreDebug = (0, logger_1.makeDebug)('non-oclif-perf');
         const nonCorePerf = Performance.results;
         if (nonCorePerf.size > 0) {
             nonCoreDebug('Non-Core Performance Measurements:');

package/lib/settings.d.ts

@@ -5,25 +5,19 @@ export type Settings = {
      * Environment Variable:
      *   OCLIF_COLUMNS=80
      */
-    columns?: number;
+    columns?: number | undefined;
     /**
      * Show additional debug output without DEBUG. Mainly shows stackstraces.
      *
      * Useful to set in the ./bin/dev.js script.
      * oclif.settings.debug = true;
      */
-    debug?: boolean;
-    /**
-     * The path to the error.log file.
-     *
-     * NOTE: This is read-only and setting it will have no effect.
-     */
-    errlog?: string;
+    debug?: boolean | undefined;
     /**
      * Enable performance tracking. Resulting data is available in the `perf` property of the `Config` class.
      * This will be overridden by the `enablePerf` property passed into Config constructor.
      */
-    performanceEnabled?: boolean;
+    performanceEnabled?: boolean | undefined;
     /**
      * Try to use ts-node to load typescript source files instead of javascript files.
      * Defaults to true in development and test environments (e.g. using bin/dev.js or
@@ -31,12 +25,12 @@ export type Settings = {
      *
      * @deprecated use enableAutoTranspile instead.
      */
-    tsnodeEnabled?: boolean;
+    tsnodeEnabled?: boolean | undefined;
     /**
      * Enable automatic transpilation of TypeScript files to JavaScript.
      *
      * Defaults to true in development and test environments (e.g. using bin/dev.js or NODE_ENV=development or NODE_ENV=test).
      */
-    enableAutoTranspile?: boolean;
+    enableAutoTranspile?: boolean | undefined;
 };
 export declare const settings: Settings;

package/lib/util/determine-priority.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '../command';
+/**
+ * This function 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
+ */
+export declare function determinePriority(plugins: string[], commands: Command.Loadable[]): Command.Loadable;

package/lib/util/determine-priority.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determinePriority = void 0;
+/**
+ * This function 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
+ */
+function determinePriority(plugins, commands) {
+    const commandPlugins = commands.sort((a, b) => {
+        const pluginAliasA = a.pluginAlias ?? 'A-Cannot-Find-This';
+        const pluginAliasB = b.pluginAlias ?? 'B-Cannot-Find-This';
+        const aIndex = plugins.indexOf(pluginAliasA);
+        const bIndex = plugins.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];
+}
+exports.determinePriority = determinePriority;

package/lib/util/find-root.d.ts

@@ -1,3 +1,4 @@
+export declare function debug(...scope: string[]): (..._: any) => void;
 /**
  * Returns the root directory of the plugin.
  *

package/lib/util/find-root.js

@@ -1,13 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findRoot = void 0;
-const debug_1 = __importDefault(require("debug"));
+exports.findRoot = exports.debug = void 0;
 const node_path_1 = require("node:path");
+const logger_1 = require("../logger");
 const fs_1 = require("./fs");
-const debug = (0, debug_1.default)('find-root');
+function debug(...scope) {
+    return (formatter, ...args) => (0, logger_1.getLogger)(['find-root', ...scope].join(':')).debug(formatter, ...args);
+}
+exports.debug = debug;
 // essentially just "cd .."
 function* up(from) {
     while ((0, node_path_1.dirname)(from) !== from) {
@@ -25,11 +25,11 @@ function* up(from) {
 async function findPluginRoot(root, name) {
     // If we know the plugin name then we just need to traverse the file
     // system until we find the directory that matches the plugin name.
-    debug.extend(name ?? 'root-plugin')(`Finding root starting at ${root}`);
+    debug(name ?? 'root-plugin')(`Finding root starting at ${root}`);
     if (name) {
         for (const next of up(root)) {
             if (next.endsWith((0, node_path_1.basename)(name))) {
-                debug.extend(name)('Found root based on plugin name!');
+                debug(name)('Found root based on plugin name!');
                 return next;
             }
         }
@@ -44,9 +44,9 @@ async function findPluginRoot(root, name) {
         }
         try {
             const cur = (0, node_path_1.join)(next, 'package.json');
-            debug.extend(name ?? 'root-plugin')(`Checking ${cur}`);
+            debug(name ?? 'root-plugin')(`Checking ${cur}`);
             if (await (0, fs_1.safeReadJson)(cur)) {
-                debug.extend(name ?? 'root-plugin')('Found root by traversing up from starting point!');
+                debug(name ?? 'root-plugin')('Found root by traversing up from starting point!');
                 return (0, node_path_1.dirname)(cur);
             }
         }
@@ -60,7 +60,7 @@ async function findPluginRoot(root, name) {
  * See https://github.com/oclif/config/pull/289#issuecomment-983904051
  */
 async function findRootLegacy(name, root) {
-    debug.extend(name ?? 'root-plugin')('Finding root using legacy method');
+    debug(name ?? 'root-plugin')('Finding root using legacy method');
     for (const next of up(root)) {
         let cur;
         if (name) {
@@ -106,7 +106,7 @@ function findPnpRoot(name, root) {
     maybeRequirePnpApi(root);
     if (!pnp)
         return;
-    debug.extend(name)('Finding root for using pnp method');
+    debug(name)('Finding root for using pnp method');
     const seen = new Set();
     const traverseDependencyTree = (locator, parentPkg) => {
         // Prevent infinite recursion when A depends on B which depends on A
@@ -158,29 +158,29 @@ function findPnpRoot(name, root) {
  */
 async function findRoot(name, root) {
     if (name) {
-        debug.extend(name)(`Finding root using ${root}`);
+        debug(name)(`Finding root using ${root}`);
         let pkgPath;
         try {
             pkgPath = require.resolve(name, { paths: [root] });
-            debug.extend(name)(`Found starting point with require.resolve`);
+            debug(name)(`Found starting point with require.resolve`);
         }
         catch {
-            debug.extend(name)(`require.resolve could not find plugin starting point`);
+            debug(name)(`require.resolve could not find plugin starting point`);
         }
         if (pkgPath) {
             const found = await findPluginRoot((0, node_path_1.dirname)(pkgPath), name);
             if (found) {
-                debug.extend(name)(`Found root at ${found}`);
+                debug(name)(`Found root at ${found}`);
                 return found;
             }
         }
         const found = process.versions.pnp ? findPnpRoot(name, root) : await findRootLegacy(name, root);
-        debug.extend(name)(found ? `Found root at ${found}` : 'No root found!');
+        debug(name)(found ? `Found root at ${found}` : 'No root found!');
         return found;
     }
-    debug.extend('root-plugin')(`Finding root plugin using ${root}`);
+    debug('root-plugin')(`Finding root plugin using ${root}`);
     const found = await findPluginRoot(root);
-    debug.extend('root-plugin')(found ? `Found root at ${found}` : 'No root found!');
+    debug('root-plugin')(found ? `Found root at ${found}` : 'No root found!');
     return found;
 }
 exports.findRoot = findRoot;

package/lib/util/fs.js

@@ -43,17 +43,29 @@ const fileExists = async (input) => {
     return input;
 };
 exports.fileExists = fileExists;
+const cache = new Map();
 async function readJson(path) {
+    if (cache.has(path)) {
+        return JSON.parse(cache.get(path));
+    }
     const contents = await (0, promises_1.readFile)(path, 'utf8');
+    cache.set(path, contents);
     return JSON.parse(contents);
 }
 exports.readJson = readJson;
 function readJsonSync(path, parse = true) {
+    if (cache.has(path)) {
+        return JSON.parse(cache.get(path));
+    }
     const contents = (0, node_fs_1.readFileSync)(path, 'utf8');
+    cache.set(path, contents);
     return parse ? JSON.parse(contents) : contents;
 }
 exports.readJsonSync = readJsonSync;
 async function safeReadJson(path) {
+    if (cache.has(path)) {
+        return JSON.parse(cache.get(path));
+    }
     try {
         return await readJson(path);
     }

package/lib/util/ids.d.ts

@@ -1,3 +1,3 @@
-import { Config } from '../interfaces';
+import { type Config } from '../interfaces/config';
 export declare function toStandardizedId(commandID: string, config: Config): string;
 export declare function toConfiguredId(commandID: string, config: Config): string;

package/lib/util/read-pjson.d.ts

@@ -0,0 +1,7 @@
+import { PJSON } from '../interfaces';
+/**
+ * Read the package.json file from a given path and add the oclif config (found by cosmiconfig) if it exists.
+ *
+ * We can assume that the package.json file exists because the plugin root has already been loaded at this point.
+ */
+export declare function readPjson(path: string): Promise<PJSON>;