@oclif/core 3.0.0-beta.1 → 3.0.0-beta.3

package/lib/config/plugin-loader.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const Plugin = require("./plugin");
+const util_1 = require("./util");
+const util_2 = require("../util");
+const performance_1 = require("../performance");
+// eslint-disable-next-line new-cap
+const debug = (0, util_1.Debug)();
+class PluginLoader {
+    constructor(options) {
+        this.options = options;
+        this.plugins = new Map();
+        this.errors = [];
+        this.pluginsProvided = false;
+        if (options.plugins) {
+            this.pluginsProvided = true;
+            this.plugins = Array.isArray(options.plugins) ? new Map(options.plugins.map(p => [p.name, p])) : options.plugins;
+        }
+    }
+    async loadRoot() {
+        let rootPlugin;
+        if (this.pluginsProvided) {
+            const plugins = [...this.plugins.values()];
+            rootPlugin = plugins.find(p => p.root === this.options.root) ?? plugins[0];
+        }
+        else {
+            rootPlugin = new Plugin.Plugin({ root: this.options.root });
+            await rootPlugin.load();
+        }
+        this.plugins.set(rootPlugin.name, rootPlugin);
+        return rootPlugin;
+    }
+    async loadChildren(opts) {
+        if (!this.pluginsProvided || opts.force) {
+            await this.loadUserPlugins(opts);
+            await this.loadDevPlugins(opts);
+            await this.loadCorePlugins(opts);
+        }
+        return { plugins: this.plugins, errors: this.errors };
+    }
+    async loadCorePlugins(opts) {
+        if (opts.rootPlugin.pjson.oclif.plugins) {
+            await this.loadPlugins(opts.rootPlugin.root, 'core', opts.rootPlugin.pjson.oclif.plugins);
+        }
+    }
+    async loadDevPlugins(opts) {
+        if (opts.devPlugins !== false) {
+            // do not load oclif.devPlugins in production
+            if ((0, util_2.isProd)())
+                return;
+            try {
+                const devPlugins = opts.rootPlugin.pjson.oclif.devPlugins;
+                if (devPlugins)
+                    await this.loadPlugins(opts.rootPlugin.root, 'dev', devPlugins);
+            }
+            catch (error) {
+                process.emitWarning(error);
+            }
+        }
+    }
+    async loadUserPlugins(opts) {
+        if (opts.userPlugins !== false) {
+            try {
+                const userPJSONPath = path.join(opts.dataDir, 'package.json');
+                debug('reading user plugins pjson %s', userPJSONPath);
+                const pjson = await (0, util_1.loadJSON)(userPJSONPath);
+                if (!pjson.oclif)
+                    pjson.oclif = { schema: 1 };
+                if (!pjson.oclif.plugins)
+                    pjson.oclif.plugins = [];
+                await this.loadPlugins(userPJSONPath, 'user', pjson.oclif.plugins.filter((p) => p.type === 'user'));
+                await this.loadPlugins(userPJSONPath, 'link', pjson.oclif.plugins.filter((p) => p.type === 'link'));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    process.emitWarning(error);
+            }
+        }
+    }
+    async loadPlugins(root, type, plugins, parent) {
+        if (!plugins || plugins.length === 0)
+            return;
+        const mark = performance_1.default.mark(`config.loadPlugins#${type}`);
+        debug('loading plugins', plugins);
+        await Promise.all((plugins || []).map(async (plugin) => {
+            try {
+                const name = typeof plugin === 'string' ? plugin : plugin.name;
+                const opts = {
+                    name,
+                    type,
+                    root,
+                };
+                if (typeof plugin !== 'string') {
+                    opts.tag = plugin.tag || opts.tag;
+                    opts.root = plugin.root || opts.root;
+                }
+                if (this.plugins.has(name))
+                    return;
+                const pluginMarker = performance_1.default.mark(`plugin.load#${name}`);
+                const instance = new Plugin.Plugin(opts);
+                await instance.load();
+                pluginMarker?.addDetails({
+                    hasManifest: instance.hasManifest,
+                    commandCount: instance.commands.length,
+                    topicCount: instance.topics.length,
+                    type: instance.type,
+                    usesMain: Boolean(instance.pjson.main),
+                    name: instance.name,
+                });
+                pluginMarker?.stop();
+                this.plugins.set(instance.name, instance);
+                if (parent) {
+                    instance.parent = parent;
+                    if (!parent.children)
+                        parent.children = [];
+                    parent.children.push(instance);
+                }
+                await this.loadPlugins(instance.root, type, instance.pjson.oclif.plugins || [], instance);
+            }
+            catch (error) {
+                this.errors.push(error);
+            }
+        }));
+        mark?.addDetails({ pluginCount: plugins.length });
+        mark?.stop();
+    }
+}
+exports.default = PluginLoader;

package/lib/config/plugin.d.ts

@@ -1,4 +1,3 @@
-import { CLIError } from '../errors';
 import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
 import { Manifest } from '../interfaces/manifest';
 import { PJSON } from '../interfaces/pjson';
@@ -11,6 +10,7 @@ export declare class Plugin implements IPlugin {
     version: string;
     pjson: PJSON.Plugin;
     type: string;
+    moduleType: 'module' | 'commonjs';
     root: string;
     alias: string;
     tag?: string;
@@ -25,16 +25,11 @@ export declare class Plugin implements IPlugin {
     children: Plugin[];
     hasManifest: boolean;
     private _commandsDir;
+    private flexibleTaxonomy;
     protected _debug: (..._: any) => void;
     protected warned: boolean;
     constructor(options: PluginOptions);
-    /**
-     * Loads a plugin
-     * @param isWritingManifest - if true, exclude selected data from manifest
-     * default is false to maintain backwards compatibility
-     * @returns Promise<void>
-     */
-    load(isWritingManifest?: boolean): Promise<void>;
+    load(): Promise<void>;
     get topics(): Topic[];
     get commandsDir(): string | undefined;
     get commandIDs(): string[];
@@ -44,7 +39,7 @@ export declare class Plugin implements IPlugin {
     findCommand(id: string, opts?: {
         must: boolean;
     }): Promise<Command.Class | undefined>;
-    protected _manifest(ignoreManifest: boolean, errorOnManifestCreate?: boolean, isWritingManifest?: boolean): Promise<Manifest>;
-    protected warn(err: string | Error | CLIError, scope?: string): void;
+    private _manifest;
+    private warn;
     private addErrorScope;
 }

package/lib/config/plugin.js

@@ -90,7 +90,6 @@ async function findRoot(name, root) {
 class Plugin {
     constructor(options) {
         this.options = options;
-        // static loadedPlugins: {[name: string]: Plugin} = {}
         this._base = `${_pjson.name}@${_pjson.version}`;
         this.valid = false;
         this.alreadyLoaded = false;
@@ -100,26 +99,22 @@ class Plugin {
         this._debug = (0, util_2.Debug)();
         this.warned = false;
     }
-    /**
-     * Loads a plugin
-     * @param isWritingManifest - if true, exclude selected data from manifest
-     * default is false to maintain backwards compatibility
-     * @returns Promise<void>
-     */
-    async load(isWritingManifest) {
+    async load() {
         this.type = this.options.type || 'core';
         this.tag = this.options.tag;
         const root = await findRoot(this.options.name, this.options.root);
         if (!root)
-            throw new Error(`could not find package.json with ${(0, util_1.inspect)(this.options)}`);
+            throw new errors_1.CLIError(`could not find package.json with ${(0, util_1.inspect)(this.options)}`);
         this.root = root;
         this._debug('reading %s plugin %s', this.type, root);
         this.pjson = await (0, util_3.loadJSON)(path.join(root, 'package.json'));
+        this.flexibleTaxonomy = this.options?.flexibleTaxonomy || this.pjson.oclif?.flexibleTaxonomy || false;
+        this.moduleType = this.pjson.type === 'module' ? 'module' : 'commonjs';
         this.name = this.pjson.name;
         this.alias = this.options.name ?? this.pjson.name;
         const pjsonPath = path.join(root, 'package.json');
         if (!this.name)
-            throw new Error(`no name in ${pjsonPath}`);
+            throw new errors_1.CLIError(`no name in ${pjsonPath}`);
         if (!(0, util_4.isProd)() && !this.pjson.files)
             this.warn(`files attribute must be specified in ${pjsonPath}`);
         // eslint-disable-next-line new-cap
@@ -132,7 +127,7 @@ class Plugin {
             this.pjson.oclif = this.pjson['cli-engine'] || {};
         }
         this.hooks = (0, util_3.mapValues)(this.pjson.oclif.hooks || {}, i => Array.isArray(i) ? i : [i]);
-        this.manifest = await this._manifest(Boolean(this.options.ignoreManifest), Boolean(this.options.errorOnManifestCreate), isWritingManifest);
+        this.manifest = await this._manifest();
         this.commands = Object
             .entries(this.manifest.commands)
             .map(([id, c]) => ({
@@ -149,13 +144,13 @@ class Plugin {
     get commandsDir() {
         if (this._commandsDir)
             return this._commandsDir;
-        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this.type);
+        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
         return this._commandsDir;
     }
     get commandIDs() {
         if (!this.commandsDir)
             return [];
-        const marker = performance_1.Performance.mark(`plugin.commandIDs#${this.name}`, { plugin: this.name });
+        const marker = performance_1.default.mark(`plugin.commandIDs#${this.name}`, { plugin: this.name });
         this._debug(`loading IDs from ${this.commandsDir}`);
         const patterns = [
             '**/*.+(js|cjs|mjs|ts|tsx)',
@@ -175,7 +170,7 @@ class Plugin {
         return ids;
     }
     async findCommand(id, opts = {}) {
-        const marker = performance_1.Performance.mark(`plugin.findCommand#${this.name}.${id}`, { id, plugin: this.name });
+        const marker = performance_1.default.mark(`plugin.findCommand#${this.name}.${id}`, { id, plugin: this.name });
         const fetch = async () => {
             if (!this.commandsDir)
                 return;
@@ -211,7 +206,10 @@ class Plugin {
         marker?.stop();
         return cmd;
     }
-    async _manifest(ignoreManifest, errorOnManifestCreate = false, isWritingManifest = false) {
+    async _manifest() {
+        const ignoreManifest = Boolean(this.options.ignoreManifest);
+        const errorOnManifestCreate = Boolean(this.options.errorOnManifestCreate);
+        const respectNoCacheDefault = Boolean(this.options.respectNoCacheDefault);
         const readManifest = async (dotfile = false) => {
             try {
                 const p = path.join(this.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
@@ -235,7 +233,7 @@ class Plugin {
                 }
             }
         };
-        const marker = performance_1.Performance.mark(`plugin.manifest#${this.name}`, { plugin: this.name });
+        const marker = performance_1.default.mark(`plugin.manifest#${this.name}`, { plugin: this.name });
         if (!ignoreManifest) {
             const manifest = await readManifest();
             if (manifest) {
@@ -248,7 +246,13 @@ class Plugin {
             version: this.version,
             commands: (await Promise.all(this.commandIDs.map(async (id) => {
                 try {
-                    return [id, await (0, config_1.toCached)(await this.findCommand(id, { must: true }), this, isWritingManifest)];
+                    const cached = await (0, config_1.toCached)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
+                    if (this.flexibleTaxonomy) {
+                        const permutations = (0, util_2.getCommandIdPermutations)(id);
+                        const aliasPermutations = cached.aliases.flatMap(a => (0, util_2.getCommandIdPermutations)(a));
+                        return [id, { ...cached, permutations, aliasPermutations }];
+                    }
+                    return [id, cached];
                 }
                 catch (error) {
                     const scope = 'toCached';

package/lib/config/ts-node.d.ts

@@ -1,7 +1,8 @@
+import { Plugin } from '../interfaces';
 /**
  * Convert a path from the compiled ./lib files to the ./src typescript source
  * this is for developing typescript plugins/CLIs
  * if there is a tsconfig and the original sources exist, it attempts to require ts-node
  */
-export declare function tsPath(root: string, orig: string, type?: string): string;
-export declare function tsPath(root: string, orig: string | undefined, type?: string): string | undefined;
+export declare function tsPath(root: string, orig: string, plugin: Plugin): string;
+export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin): string | undefined;

package/lib/config/ts-node.js

@@ -6,11 +6,15 @@ const path = require("path");
 const settings_1 = require("../settings");
 const util_1 = require("../util");
 const util_2 = require("./util");
+const config_1 = require("./config");
+const errors_1 = require("../errors");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)('ts-node');
-const TYPE_ROOTS = [`${__dirname}/../node_modules/@types`];
-const ROOT_DIRS = [];
+const TS_CONFIGS = {};
+const REGISTERED = new Set();
 function loadTSConfig(root) {
+    if (TS_CONFIGS[root])
+        return TS_CONFIGS[root];
     const tsconfigPath = path.join(root, 'tsconfig.json');
     let typescript;
     try {
@@ -18,7 +22,7 @@ function loadTSConfig(root) {
     }
     catch {
         try {
-            typescript = require(root + '/node_modules/typescript');
+            typescript = require(path.join(root, 'node_modules', 'typescript'));
         }
         catch { }
     }
@@ -28,6 +32,7 @@ function loadTSConfig(root) {
             throw new Error(`Could not read and parse tsconfig.json at ${tsconfigPath}, or it ` +
                 'did not contain a "compilerOptions" section.');
         }
+        TS_CONFIGS[root] = tsconfig;
         return tsconfig;
     }
 }
@@ -35,54 +40,96 @@ function registerTSNode(root) {
     const tsconfig = loadTSConfig(root);
     if (!tsconfig)
         return;
+    if (REGISTERED.has(root))
+        return tsconfig;
     debug('registering ts-node at', root);
     const tsNodePath = require.resolve('ts-node', { paths: [root, __dirname] });
+    debug('ts-node path:', tsNodePath);
     const tsNode = require(tsNodePath);
-    TYPE_ROOTS.push(`${root}/node_modules/@types`);
+    const typeRoots = [
+        path.join(root, 'node_modules', '@types'),
+    ];
+    const rootDirs = [];
     if (tsconfig.compilerOptions.rootDirs) {
-        ROOT_DIRS.push(...tsconfig.compilerOptions.rootDirs.map(r => path.join(root, r)));
+        for (const r of tsconfig.compilerOptions.rootDirs) {
+            rootDirs.push(path.join(root, r));
+        }
+    }
+    else if (tsconfig.compilerOptions.rootDir) {
+        rootDirs.push(path.join(root, tsconfig.compilerOptions.rootDir));
     }
     else {
-        ROOT_DIRS.push(`${root}/src`);
+        rootDirs.push(path.join(root, 'src'));
     }
-    const cwd = process.cwd();
-    try {
-        process.chdir(root);
-        tsNode.register({
-            skipProject: true,
-            transpileOnly: true,
-            compilerOptions: {
-                esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
-                target: tsconfig.compilerOptions.target || 'es2017',
-                experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators || false,
-                emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata || false,
-                module: 'commonjs',
-                sourceMap: true,
-                rootDirs: ROOT_DIRS,
-                typeRoots: TYPE_ROOTS,
-                jsx: 'react',
-            },
-        });
-        return tsconfig;
+    const conf = {
+        compilerOptions: {
+            esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
+            target: tsconfig.compilerOptions.target ?? 'es2019',
+            experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators ?? false,
+            emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata ?? false,
+            module: tsconfig.compilerOptions.module ?? 'commonjs',
+            sourceMap: tsconfig.compilerOptions.sourceMap ?? true,
+            rootDirs,
+            typeRoots,
+        },
+        skipProject: true,
+        transpileOnly: true,
+        esm: tsconfig['ts-node']?.esm ?? true,
+        scope: true,
+        scopeDir: root,
+        cwd: root,
+        experimentalSpecifierResolution: tsconfig['ts-node']?.experimentalSpecifierResolution ?? 'explicit',
+    };
+    if (tsconfig.compilerOptions.moduleResolution) {
+        // @ts-expect-error TSNode.RegisterOptions.compilerOptions is typed as a plain object
+        conf.compilerOptions.moduleResolution = tsconfig.compilerOptions.moduleResolution;
     }
-    finally {
-        process.chdir(cwd);
+    if (tsconfig.compilerOptions.jsx) {
+        // @ts-expect-error TSNode.RegisterOptions.compilerOptions is typed as a plain object
+        conf.compilerOptions.jsx = tsconfig.compilerOptions.jsx;
     }
+    tsNode.register(conf);
+    REGISTERED.add(root);
+    return tsconfig;
 }
-function tsPath(root, orig, type) {
+// eslint-disable-next-line complexity
+function tsPath(root, orig, plugin) {
     if (!orig)
         return orig;
     orig = orig.startsWith(root) ? orig : path.join(root, orig);
-    const skipTSNode = 
-    // the CLI specifically turned it off
-    (settings_1.settings.tsnodeEnabled === false) ||
-        // the CLI didn't specify ts-node and it is production
-        (settings_1.settings.tsnodeEnabled === undefined && (0, util_1.isProd)());
-    // We always want to load the tsconfig for linked plugins.
-    if (skipTSNode && type !== 'link')
+    // NOTE: The order of these checks matter!
+    if (settings_1.default.tsnodeEnabled === false) {
+        debug(`Skipping ts-node registration for ${root} because tsNodeEnabled is explicitly set to false`);
+        return orig;
+    }
+    // Skip ts-node registration if plugin is an ESM plugin executing from a CJS plugin
+    if (plugin?.moduleType === 'module' && config_1.Config.rootPlugin?.moduleType === 'commonjs') {
+        debug(`Skipping ts-node registration for ${root} because it's an ESM module but the root plugin is CommonJS`);
+        if (plugin.type === 'link')
+            (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-compiled from a CommonJS root plugin. Existing compiled source will be used instead.`);
         return orig;
+    }
+    // If plugin is an ESM plugin being executed from an ESM root plugin, check to see if ts-node/esm loader has been set
+    // either in the NODE_OPTIONS env var or from the exec args. If the ts-node/esm loader has NOT been loaded then we want
+    // to skip ts-node registration so that it falls back on the compiled source.
+    if (plugin?.moduleType === 'module') {
+        const tsNodeEsmLoaderInExecArgv = process.execArgv.includes('--loader') && process.execArgv.includes('ts-node/esm');
+        const tsNodeEsmLoaderInNodeOptions = process.env.NODE_OPTIONS?.includes('--loader=ts-node/esm') ?? false;
+        if (!tsNodeEsmLoaderInExecArgv && !tsNodeEsmLoaderInNodeOptions) {
+            debug(`Skipping ts-node registration for ${root} because it's an ESM module but the ts-node/esm loader hasn't been run`);
+            debug('try setting NODE_OPTIONS="--loader ts-node/esm" in your environment.');
+            if (plugin.type === 'link') {
+                (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-compiled without setting NODE_OPTIONS="--loader=ts-node/esm" in the environment. Existing compiled source will be used instead.`);
+            }
+            return orig;
+        }
+    }
+    if (settings_1.default.tsnodeEnabled === undefined && (0, util_1.isProd)() && plugin?.type !== 'link') {
+        debug(`Skipping ts-node registration for ${root} because NODE_ENV is NOT "test" or "development"`);
+        return orig;
+    }
     try {
-        const tsconfig = type === 'link' ? registerTSNode(root) : loadTSConfig(root);
+        const tsconfig = registerTSNode(root);
         if (!tsconfig)
             return orig;
         const { rootDir, rootDirs, outDir } = tsconfig.compilerOptions;

package/lib/errors/config.js

@@ -15,24 +15,24 @@ function displayWarnings() {
 exports.config = {
     errorLogger: undefined,
     get debug() {
-        return Boolean(settings_1.settings.debug);
+        return Boolean(settings_1.default.debug);
     },
     set debug(enabled) {
-        settings_1.settings.debug = enabled;
+        settings_1.default.debug = enabled;
         if (enabled)
             displayWarnings();
     },
     get errlog() {
-        return settings_1.settings.errlog;
+        return settings_1.default.errlog;
     },
     set errlog(errlog) {
         if (errlog) {
             this.errorLogger = new logger_1.Logger(errlog);
-            settings_1.settings.errlog = errlog;
+            settings_1.default.errlog = errlog;
         }
         else {
             delete this.errorLogger;
-            delete settings_1.settings.errlog;
+            delete settings_1.default.errlog;
         }
     },
 };

package/lib/errors/errors/cli.d.ts

@@ -8,6 +8,7 @@ export declare function addOclifExitCode(error: Record<string, any>, options?: {
 export declare class CLIError extends Error implements OclifError {
     oclif: OclifError['oclif'];
     code?: string;
+    suggestions?: string[];
     constructor(error: string | Error, options?: {
         exit?: number | false;
     } & PrettyPrintableError);

package/lib/errors/errors/cli.js

@@ -24,6 +24,7 @@ class CLIError extends Error {
         this.oclif = {};
         addOclifExitCode(this, options);
         this.code = options.code;
+        this.suggestions = options.suggestions;
     }
     get stack() {
         return cs(super.stack, { pretty: true });

package/lib/errors/handle.d.ts

@@ -1,4 +1,4 @@
 import { OclifError, PrettyPrintableError } from '../interfaces';
-export declare const handle: (err: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
+export default function handle(err: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
     skipOclifErrorHandling?: boolean;
-}) => void;
+}): Promise<void>;

package/lib/errors/handle.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handle = void 0;
 /* eslint-disable no-process-exit */
 /* eslint-disable unicorn/no-process-exit */
 const config_1 = require("./config");
@@ -8,7 +7,7 @@ const pretty_print_1 = require("./errors/pretty-print");
 const _1 = require(".");
 const clean = require("clean-stack");
 const cli_1 = require("./errors/cli");
-const handle = (err) => {
+async function handle(err) {
     try {
         if (!err)
             err = new cli_1.CLIError('no error?');
@@ -25,7 +24,7 @@ const handle = (err) => {
             if (stack) {
                 config_1.config.errorLogger.log(stack);
             }
-            config_1.config.errorLogger.flush()
+            await config_1.config.errorLogger.flush()
                 .then(() => process.exit(exitCode))
                 .catch(console.error);
         }
@@ -37,5 +36,5 @@ const handle = (err) => {
         console.error(error.stack);
         process.exit(1);
     }
-};
-exports.handle = handle;
+}
+exports.default = handle;

package/lib/errors/index.d.ts

@@ -1,4 +1,4 @@
-export { handle } from './handle';
+export { default as handle } from './handle';
 export { ExitError } from './errors/exit';
 export { ModuleLoadError } from './errors/module-load';
 export { CLIError } from './errors/cli';
@@ -14,3 +14,4 @@ export declare function error(input: string | Error, options?: {
     exit?: number;
 } & PrettyPrintableError): never;
 export declare function warn(input: string | Error): void;
+export declare function memoizedWarn(input: string | Error): void;

package/lib/errors/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warn = exports.error = exports.exit = exports.config = exports.Logger = exports.CLIError = exports.ModuleLoadError = exports.ExitError = exports.handle = void 0;
+exports.memoizedWarn = exports.warn = exports.error = exports.exit = exports.config = exports.Logger = exports.CLIError = exports.ModuleLoadError = exports.ExitError = exports.handle = void 0;
 var handle_1 = require("./handle");
-Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
+Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.default; } });
 var exit_1 = require("./errors/exit");
 Object.defineProperty(exports, "ExitError", { enumerable: true, get: function () { return exit_1.ExitError; } });
 var module_load_1 = require("./errors/module-load");
@@ -60,3 +60,10 @@ function warn(input) {
         config_2.config.errorLogger.log(err?.stack ?? '');
 }
 exports.warn = warn;
+const WARNINGS = new Set();
+function memoizedWarn(input) {
+    if (!WARNINGS.has(input))
+        warn(input);
+    WARNINGS.add(input);
+}
+exports.memoizedWarn = memoizedWarn;

package/lib/errors/logger.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
-const fs = require("fs-extra");
-const path = require("path");
+const fs = require("fs/promises");
+const path_1 = require("path");
 const stripAnsi = require("strip-ansi");
 const timestamp = () => new Date().toISOString();
 let timer;
@@ -35,7 +35,7 @@ class Logger {
                 return;
             const mylines = this.buffer;
             this.buffer = [];
-            await fs.mkdirp(path.dirname(this.file));
+            await fs.mkdir((0, path_1.dirname)(this.file), { recursive: true });
             await fs.appendFile(this.file, mylines.join('\n') + '\n');
         });
         await this.flushing;

package/lib/execute.d.ts

@@ -0,0 +1,49 @@
+import * as Interfaces from './interfaces';
+/**
+ * Load and run oclif CLI
+ *
+ * @param options - options to load the CLI
+ * @returns Promise<void>
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: __dirname})
+ * })()
+ * ```
+ *
+ * @example For CJS run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: __dirname})
+ * })()
+ * ```
+ */
+export default function execute(options: {
+    dir: string;
+    args?: string[];
+    loadOptions?: Interfaces.LoadOptions;
+    development?: boolean;
+}): Promise<unknown>;